@cleocode/adapters 2026.3.72 → 2026.3.74

package/dist/index.js

@@ -1099,14 +1099,14 @@ var init_hooks2 = __esm({
 });
 
 // packages/adapters/src/providers/cursor/install.js
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join7 } from "node:path";
-var INSTRUCTION_REFERENCES2, MCP_SERVER_KEY2, CursorInstallProvider;
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
+var INSTRUCTION_REFERENCES3, MCP_SERVER_KEY3, CursorInstallProvider;
 var init_install2 = __esm({
   "packages/adapters/src/providers/cursor/install.js"() {
     "use strict";
-    INSTRUCTION_REFERENCES2 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
-    MCP_SERVER_KEY2 = "cleo";
+    INSTRUCTION_REFERENCES3 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+    MCP_SERVER_KEY3 = "cleo";
     CursorInstallProvider = class {
       installedProjectDir = null;
       /**
@@ -1124,7 +1124,7 @@ var init_install2 = __esm({
         if (mcpServerPath) {
           mcpRegistered = this.registerMcpServer(projectDir, mcpServerPath);
           if (mcpRegistered) {
-            details.mcpConfigPath = join7(projectDir, ".cursor", "mcp.json");
+            details.mcpConfigPath = join10(projectDir, ".cursor", "mcp.json");
           }
         }
         instructionFileUpdated = this.updateInstructionFiles(projectDir);
@@ -1149,15 +1149,15 @@ var init_install2 = __esm({
       async uninstall() {
         if (!this.installedProjectDir)
           return;
-        const mcpPath = join7(this.installedProjectDir, ".cursor", "mcp.json");
-        if (existsSync5(mcpPath)) {
+        const mcpPath = join10(this.installedProjectDir, ".cursor", "mcp.json");
+        if (existsSync7(mcpPath)) {
           try {
-            const raw = readFileSync4(mcpPath, "utf-8");
+            const raw = readFileSync5(mcpPath, "utf-8");
             const config = JSON.parse(raw);
             const mcpServers = config.mcpServers;
-            if (mcpServers && MCP_SERVER_KEY2 in mcpServers) {
-              delete mcpServers[MCP_SERVER_KEY2];
-              writeFileSync3(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            if (mcpServers && MCP_SERVER_KEY3 in mcpServers) {
+              delete mcpServers[MCP_SERVER_KEY3];
+              writeFileSync4(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
             }
           } catch {
           }
@@ -1170,12 +1170,12 @@ var init_install2 = __esm({
        * Checks for MCP server registered in .cursor/mcp.json.
        */
       async isInstalled() {
-        const mcpPath = join7(process.cwd(), ".cursor", "mcp.json");
-        if (existsSync5(mcpPath)) {
+        const mcpPath = join10(process.cwd(), ".cursor", "mcp.json");
+        if (existsSync7(mcpPath)) {
           try {
-            const config = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+            const config = JSON.parse(readFileSync5(mcpPath, "utf-8"));
             const mcpServers = config.mcpServers;
-            if (mcpServers && MCP_SERVER_KEY2 in mcpServers) {
+            if (mcpServers && MCP_SERVER_KEY3 in mcpServers) {
               return true;
             }
           } catch {
@@ -1202,13 +1202,13 @@ var init_install2 = __esm({
        * @returns true if registration was performed or updated
        */
       registerMcpServer(projectDir, mcpServerPath) {
-        const cursorDir = join7(projectDir, ".cursor");
-        const mcpPath = join7(cursorDir, "mcp.json");
+        const cursorDir = join10(projectDir, ".cursor");
+        const mcpPath = join10(cursorDir, "mcp.json");
         let config = {};
-        mkdirSync2(cursorDir, { recursive: true });
-        if (existsSync5(mcpPath)) {
+        mkdirSync3(cursorDir, { recursive: true });
+        if (existsSync7(mcpPath)) {
           try {
-            config = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+            config = JSON.parse(readFileSync5(mcpPath, "utf-8"));
           } catch {
           }
         }
@@ -1216,11 +1216,11 @@ var init_install2 = __esm({
           config.mcpServers = {};
         }
         const mcpServers = config.mcpServers;
-        mcpServers[MCP_SERVER_KEY2] = {
+        mcpServers[MCP_SERVER_KEY3] = {
           command: "node",
           args: [mcpServerPath]
         };
-        writeFileSync3(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        writeFileSync4(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
         return true;
       }
       /**
@@ -1247,18 +1247,18 @@ var init_install2 = __esm({
        * @returns true if the file was modified
        */
       updateLegacyRules(projectDir) {
-        const rulesPath = join7(projectDir, ".cursorrules");
-        if (!existsSync5(rulesPath)) {
+        const rulesPath = join10(projectDir, ".cursorrules");
+        if (!existsSync7(rulesPath)) {
           return false;
         }
-        let content = readFileSync4(rulesPath, "utf-8");
-        const missingRefs = INSTRUCTION_REFERENCES2.filter((ref) => !content.includes(ref));
+        let content = readFileSync5(rulesPath, "utf-8");
+        const missingRefs = INSTRUCTION_REFERENCES3.filter((ref) => !content.includes(ref));
         if (missingRefs.length === 0) {
           return false;
         }
         const separator = content.endsWith("\n") ? "" : "\n";
         content = content + separator + missingRefs.join("\n") + "\n";
-        writeFileSync3(rulesPath, content, "utf-8");
+        writeFileSync4(rulesPath, content, "utf-8");
         return true;
       }
       /**
@@ -1270,8 +1270,8 @@ var init_install2 = __esm({
        * @returns true if the file was created or modified
        */
       updateModernRules(projectDir) {
-        const rulesDir = join7(projectDir, ".cursor", "rules");
-        const mdcPath = join7(rulesDir, "cleo.mdc");
+        const rulesDir = join10(projectDir, ".cursor", "rules");
+        const mdcPath = join10(rulesDir, "cleo.mdc");
         const expectedContent = [
           "---",
           "description: CLEO task management protocol references",
@@ -1279,17 +1279,17 @@ var init_install2 = __esm({
           "alwaysApply: true",
           "---",
           "",
-          ...INSTRUCTION_REFERENCES2,
+          ...INSTRUCTION_REFERENCES3,
           ""
         ].join("\n");
-        if (existsSync5(mdcPath)) {
-          const existing = readFileSync4(mdcPath, "utf-8");
+        if (existsSync7(mdcPath)) {
+          const existing = readFileSync5(mdcPath, "utf-8");
           if (existing === expectedContent) {
             return false;
           }
         }
-        mkdirSync2(rulesDir, { recursive: true });
-        writeFileSync3(mdcPath, expectedContent, "utf-8");
+        mkdirSync3(rulesDir, { recursive: true });
+        writeFileSync4(mdcPath, expectedContent, "utf-8");
         return true;
       }
       /**
@@ -1297,10 +1297,10 @@ var init_install2 = __esm({
        */
       getUpdatedFileList(projectDir) {
         const files = [];
-        if (existsSync5(join7(projectDir, ".cursorrules"))) {
-          files.push(join7(projectDir, ".cursorrules"));
+        if (existsSync7(join10(projectDir, ".cursorrules"))) {
+          files.push(join10(projectDir, ".cursorrules"));
         }
-        files.push(join7(projectDir, ".cursor", "rules", "cleo.mdc"));
+        files.push(join10(projectDir, ".cursor", "rules", "cleo.mdc"));
         return files;
       }
     };
@@ -1308,8 +1308,8 @@ var init_install2 = __esm({
 });
 
 // packages/adapters/src/providers/cursor/adapter.js
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 var CursorAdapter;
 var init_adapter2 = __esm({
   "packages/adapters/src/providers/cursor/adapter.js"() {
@@ -1382,14 +1382,14 @@ var init_adapter2 = __esm({
         }
         let configExists = false;
         if (this.projectDir) {
-          const cursorConfigDir = join8(this.projectDir, ".cursor");
-          configExists = existsSync6(cursorConfigDir);
+          const cursorConfigDir = join11(this.projectDir, ".cursor");
+          configExists = existsSync8(cursorConfigDir);
           details.configDirExists = configExists;
         }
         const editorEnvSet = process.env.CURSOR_EDITOR !== void 0;
         details.editorEnvSet = editorEnvSet;
         if (this.projectDir) {
-          const legacyRulesExist = existsSync6(join8(this.projectDir, ".cursorrules"));
+          const legacyRulesExist = existsSync8(join11(this.projectDir, ".cursorrules"));
           details.legacyRulesExist = legacyRulesExist;
         }
         const healthy = configExists || editorEnvSet;
@@ -1422,10 +1422,10 @@ __export(cursor_exports, {
   CursorAdapter: () => CursorAdapter,
   CursorHookProvider: () => CursorHookProvider,
   CursorInstallProvider: () => CursorInstallProvider,
-  createAdapter: () => createAdapter2,
+  createAdapter: () => createAdapter3,
   default: () => cursor_default
 });
-function createAdapter2() {
+function createAdapter3() {
   return new CursorAdapter();
 }
 var cursor_default;
@@ -1504,14 +1504,14 @@ var init_hooks3 = __esm({
 });
 
 // packages/adapters/src/providers/opencode/install.js
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join9 } from "node:path";
-var INSTRUCTION_REFERENCES3, MCP_SERVER_KEY3, OpenCodeInstallProvider;
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join17 } from "node:path";
+var INSTRUCTION_REFERENCES6, MCP_SERVER_KEY6, OpenCodeInstallProvider;
 var init_install3 = __esm({
   "packages/adapters/src/providers/opencode/install.js"() {
     "use strict";
-    INSTRUCTION_REFERENCES3 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
-    MCP_SERVER_KEY3 = "cleo";
+    INSTRUCTION_REFERENCES6 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+    MCP_SERVER_KEY6 = "cleo";
     OpenCodeInstallProvider = class {
       installedProjectDir = null;
       /**
@@ -1529,12 +1529,12 @@ var init_install3 = __esm({
         if (mcpServerPath) {
           mcpRegistered = this.registerMcpServer(projectDir, mcpServerPath);
           if (mcpRegistered) {
-            details.mcpConfigPath = join9(projectDir, ".opencode", "config.json");
+            details.mcpConfigPath = join17(projectDir, ".opencode", "config.json");
           }
         }
         instructionFileUpdated = this.updateInstructionFile(projectDir);
         if (instructionFileUpdated) {
-          details.instructionFile = join9(projectDir, "AGENTS.md");
+          details.instructionFile = join17(projectDir, "AGENTS.md");
         }
         this.installedProjectDir = projectDir;
         return {
@@ -1554,15 +1554,15 @@ var init_install3 = __esm({
       async uninstall() {
         if (!this.installedProjectDir)
           return;
-        const configPath = join9(this.installedProjectDir, ".opencode", "config.json");
-        if (existsSync7(configPath)) {
+        const configPath = join17(this.installedProjectDir, ".opencode", "config.json");
+        if (existsSync13(configPath)) {
           try {
-            const raw = readFileSync5(configPath, "utf-8");
+            const raw = readFileSync8(configPath, "utf-8");
             const config = JSON.parse(raw);
             const mcpServers = config.mcpServers;
-            if (mcpServers && MCP_SERVER_KEY3 in mcpServers) {
-              delete mcpServers[MCP_SERVER_KEY3];
-              writeFileSync4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            if (mcpServers && MCP_SERVER_KEY6 in mcpServers) {
+              delete mcpServers[MCP_SERVER_KEY6];
+              writeFileSync7(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
             }
           } catch {
           }
@@ -1576,12 +1576,12 @@ var init_install3 = __esm({
        * Returns true if the CLEO MCP server entry is found.
        */
       async isInstalled() {
-        const configPath = join9(process.cwd(), ".opencode", "config.json");
-        if (existsSync7(configPath)) {
+        const configPath = join17(process.cwd(), ".opencode", "config.json");
+        if (existsSync13(configPath)) {
           try {
-            const config = JSON.parse(readFileSync5(configPath, "utf-8"));
+            const config = JSON.parse(readFileSync8(configPath, "utf-8"));
             const mcpServers = config.mcpServers;
-            if (mcpServers && MCP_SERVER_KEY3 in mcpServers) {
+            if (mcpServers && MCP_SERVER_KEY6 in mcpServers) {
               return true;
             }
           } catch {
@@ -1608,13 +1608,13 @@ var init_install3 = __esm({
        * @returns true if registration was performed or updated
        */
       registerMcpServer(projectDir, mcpServerPath) {
-        const openCodeDir = join9(projectDir, ".opencode");
-        const configPath = join9(openCodeDir, "config.json");
+        const openCodeDir = join17(projectDir, ".opencode");
+        const configPath = join17(openCodeDir, "config.json");
         let config = {};
-        mkdirSync3(openCodeDir, { recursive: true });
-        if (existsSync7(configPath)) {
+        mkdirSync6(openCodeDir, { recursive: true });
+        if (existsSync13(configPath)) {
           try {
-            config = JSON.parse(readFileSync5(configPath, "utf-8"));
+            config = JSON.parse(readFileSync8(configPath, "utf-8"));
           } catch {
           }
         }
@@ -1622,11 +1622,11 @@ var init_install3 = __esm({
           config.mcpServers = {};
         }
         const mcpServers = config.mcpServers;
-        mcpServers[MCP_SERVER_KEY3] = {
+        mcpServers[MCP_SERVER_KEY6] = {
           command: "node",
           args: [mcpServerPath]
         };
-        writeFileSync4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        writeFileSync7(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
         return true;
       }
       /**
@@ -1635,14 +1635,14 @@ var init_install3 = __esm({
        * @returns true if the file was created or modified
        */
       updateInstructionFile(projectDir) {
-        const agentsMdPath = join9(projectDir, "AGENTS.md");
+        const agentsMdPath = join17(projectDir, "AGENTS.md");
         let content = "";
         let existed = false;
-        if (existsSync7(agentsMdPath)) {
-          content = readFileSync5(agentsMdPath, "utf-8");
+        if (existsSync13(agentsMdPath)) {
+          content = readFileSync8(agentsMdPath, "utf-8");
           existed = true;
         }
-        const missingRefs = INSTRUCTION_REFERENCES3.filter((ref) => !content.includes(ref));
+        const missingRefs = INSTRUCTION_REFERENCES6.filter((ref) => !content.includes(ref));
         if (missingRefs.length === 0) {
           return false;
         }
@@ -1653,7 +1653,7 @@ var init_install3 = __esm({
         } else {
           content = refsBlock + "\n";
         }
-        writeFileSync4(agentsMdPath, content, "utf-8");
+        writeFileSync7(agentsMdPath, content, "utf-8");
         return true;
       }
     };
@@ -1661,10 +1661,10 @@ var init_install3 = __esm({
 });
 
 // packages/adapters/src/providers/opencode/spawn.js
-import { exec as exec3, spawn as nodeSpawn2 } from "node:child_process";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { exec as exec6, spawn as nodeSpawn2 } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join18 } from "node:path";
+import { promisify as promisify6 } from "node:util";
 function buildOpenCodeAgentMarkdown(description, instructions) {
   const normalizedDesc = description.replace(/\s+/g, " ").trim();
   return [
@@ -1679,8 +1679,8 @@ function buildOpenCodeAgentMarkdown(description, instructions) {
   ].join("\n");
 }
 async function ensureSubagentDefinition(workingDirectory) {
-  const agentDir = join10(workingDirectory, ".opencode", "agent");
-  const agentPath = join10(agentDir, `${OPENCODE_SUBAGENT_NAME}.md`);
+  const agentDir = join18(workingDirectory, ".opencode", "agent");
+  const agentPath = join18(agentDir, `${OPENCODE_SUBAGENT_NAME}.md`);
   const description = "CLEO task executor with protocol compliance.";
   const instructions = [
     "# CLEO Subagent",
@@ -1694,7 +1694,7 @@ async function ensureSubagentDefinition(workingDirectory) {
   await mkdir2(agentDir, { recursive: true });
   let existing = null;
   try {
-    existing = await readFile2(agentPath, "utf-8");
+    existing = await readFile4(agentPath, "utf-8");
   } catch {
     existing = null;
   }
@@ -1703,11 +1703,11 @@ async function ensureSubagentDefinition(workingDirectory) {
   }
   return OPENCODE_SUBAGENT_NAME;
 }
-var execAsync3, OPENCODE_SUBAGENT_NAME, OPENCODE_FALLBACK_AGENT, OpenCodeSpawnProvider;
+var execAsync6, OPENCODE_SUBAGENT_NAME, OPENCODE_FALLBACK_AGENT, OpenCodeSpawnProvider;
 var init_spawn2 = __esm({
   "packages/adapters/src/providers/opencode/spawn.js"() {
     "use strict";
-    execAsync3 = promisify3(exec3);
+    execAsync6 = promisify6(exec6);
     OPENCODE_SUBAGENT_NAME = "cleo-subagent";
     OPENCODE_FALLBACK_AGENT = "general";
     OpenCodeSpawnProvider = class {
@@ -1720,7 +1720,7 @@ var init_spawn2 = __esm({
        */
       async canSpawn() {
         try {
-          await execAsync3("which opencode");
+          await execAsync6("which opencode");
           return true;
         } catch {
           return false;
@@ -1839,18 +1839,18 @@ var init_spawn2 = __esm({
 });
 
 // packages/adapters/src/providers/opencode/adapter.js
-import { exec as exec4 } from "node:child_process";
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join11 } from "node:path";
-import { promisify as promisify4 } from "node:util";
-var execAsync4, OpenCodeAdapter;
+import { exec as exec7 } from "node:child_process";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join19 } from "node:path";
+import { promisify as promisify7 } from "node:util";
+var execAsync7, OpenCodeAdapter;
 var init_adapter3 = __esm({
   "packages/adapters/src/providers/opencode/adapter.js"() {
     "use strict";
     init_hooks3();
     init_install3();
     init_spawn2();
-    execAsync4 = promisify4(exec4);
+    execAsync7 = promisify7(exec7);
     OpenCodeAdapter = class {
       id = "opencode";
       name = "OpenCode";
@@ -1931,15 +1931,15 @@ var init_adapter3 = __esm({
         }
         let cliAvailable = false;
         try {
-          const { stdout } = await execAsync4("which opencode");
+          const { stdout } = await execAsync7("which opencode");
           cliAvailable = stdout.trim().length > 0;
           details.cliPath = stdout.trim();
         } catch {
           details.cliAvailable = false;
         }
         if (this.projectDir) {
-          const openCodeConfigDir = join11(this.projectDir, ".opencode");
-          const configExists = existsSync8(openCodeConfigDir);
+          const openCodeConfigDir = join19(this.projectDir, ".opencode");
+          const configExists = existsSync14(openCodeConfigDir);
           details.configDirExists = configExists;
         }
         const versionEnvSet = process.env.OPENCODE_VERSION !== void 0;
@@ -1975,10 +1975,10 @@ __export(opencode_exports, {
   OpenCodeHookProvider: () => OpenCodeHookProvider,
   OpenCodeInstallProvider: () => OpenCodeInstallProvider,
   OpenCodeSpawnProvider: () => OpenCodeSpawnProvider,
-  createAdapter: () => createAdapter3,
+  createAdapter: () => createAdapter6,
   default: () => opencode_default
 });
-function createAdapter3() {
+function createAdapter6() {
   return new OpenCodeAdapter();
 }
 var opencode_default;
@@ -1996,12 +1996,1126 @@ var init_opencode = __esm({
 
 // packages/adapters/src/index.ts
 init_claude_code();
+
+// packages/adapters/src/providers/codex/adapter.ts
+import { exec as exec3 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join9 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+
+// packages/adapters/src/providers/codex/hooks.ts
+import { readdir, readFile as readFile2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var CODEX_EVENT_MAP = {
+  SessionStart: "SessionStart",
+  PromptSubmit: "UserPromptSubmit",
+  ResponseComplete: "Stop"
+};
+var CodexHookProvider = class {
+  registered = false;
+  /**
+   * Map a Codex CLI native event name to a CAAMP hook event name.
+   *
+   * @param providerEvent - Codex CLI event name (e.g. "SessionStart", "PromptSubmit")
+   * @returns CAAMP event name or null if unmapped
+   * @task T162
+   */
+  mapProviderEvent(providerEvent) {
+    return CODEX_EVENT_MAP[providerEvent] ?? null;
+  }
+  /**
+   * Register native hooks for a project.
+   *
+   * For Codex CLI, hooks are registered via the config system
+   * (~/.codex/), which is handled by the install provider.
+   * This method marks hooks as registered without performing
+   * filesystem operations.
+   *
+   * @param _projectDir - Project directory (unused; hooks are global)
+   * @task T162
+   */
+  async registerNativeHooks(_projectDir) {
+    this.registered = true;
+  }
+  /**
+   * Unregister native hooks.
+   *
+   * For Codex CLI, this is a no-op since hooks are managed through
+   * the config system. Unregistration happens via the install
+   * provider's uninstall method.
+   * @task T162
+   */
+  async unregisterNativeHooks() {
+    this.registered = false;
+  }
+  /**
+   * Check whether hooks have been registered via registerNativeHooks.
+   * @task T162
+   */
+  isRegistered() {
+    return this.registered;
+  }
+  /**
+   * Get the full event mapping for introspection/debugging.
+   * @task T162
+   */
+  getEventMap() {
+    return { ...CODEX_EVENT_MAP };
+  }
+  /**
+   * Extract a plain-text transcript from Codex CLI session data.
+   *
+   * Reads the most recent session file under ~/.codex/ and extracts
+   * turn text into a flat string for brain observation extraction.
+   *
+   * Returns null when no session data is found or on any read error.
+   *
+   * @param _sessionId - CLEO session ID (unused; reads the most recent file)
+   * @param _projectDir - Project directory (unused; Codex CLI uses global paths)
+   * @task T162 @epic T134
+   */
+  async getTranscript(_sessionId, _projectDir) {
+    try {
+      const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "/root";
+      const codexDir = join7(homeDir, ".codex");
+      let allFiles = [];
+      try {
+        const entries = await readdir(codexDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isFile()) continue;
+          const name = entry.name;
+          if (name.endsWith(".json") || name.endsWith(".jsonl")) {
+            allFiles.push(join7(codexDir, name));
+          }
+        }
+      } catch {
+        return null;
+      }
+      if (allFiles.length === 0) return null;
+      allFiles = allFiles.sort((a, b) => b.localeCompare(a));
+      const mostRecent = allFiles[0];
+      if (!mostRecent) return null;
+      const raw = await readFile2(mostRecent, "utf-8");
+      const turns = [];
+      const lines = raw.split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          const role = entry.role;
+          const content = entry.content;
+          if (role === "assistant" && typeof content === "string") {
+            turns.push(`assistant: ${content}`);
+          } else if (role === "user" && typeof content === "string") {
+            turns.push(`user: ${content}`);
+          }
+        } catch {
+        }
+      }
+      return turns.length > 0 ? turns.join("\n") : null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// packages/adapters/src/providers/codex/install.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join8 } from "node:path";
+var INSTRUCTION_REFERENCES2 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+var MCP_SERVER_KEY2 = "cleo";
+var CodexInstallProvider = class {
+  /**
+   * Install CLEO into a Codex CLI environment.
+   *
+   * @param options - Installation options including project directory and MCP server path
+   * @returns Result describing what was installed
+   * @task T162
+   */
+  async install(options) {
+    const { projectDir, mcpServerPath } = options;
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let instructionFileUpdated = false;
+    let mcpRegistered = false;
+    const details = {};
+    if (mcpServerPath) {
+      mcpRegistered = this.registerMcpServer(mcpServerPath);
+      if (mcpRegistered) {
+        details.mcpConfigPath = join8(homedir6(), ".codex", "config.json");
+      }
+    }
+    instructionFileUpdated = this.updateInstructionFile(projectDir);
+    if (instructionFileUpdated) {
+      details.instructionFile = join8(projectDir, "AGENTS.md");
+    }
+    return {
+      success: true,
+      installedAt,
+      instructionFileUpdated,
+      mcpRegistered,
+      details
+    };
+  }
+  /**
+   * Uninstall CLEO from the Codex CLI environment.
+   *
+   * Removes the MCP server registration from ~/.codex/config.json.
+   * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+   * @task T162
+   */
+  async uninstall() {
+    const configPath = join8(homedir6(), ".codex", "config.json");
+    if (existsSync5(configPath)) {
+      try {
+        const raw = readFileSync4(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        const mcpServers = config.mcpServers;
+        if (mcpServers && MCP_SERVER_KEY2 in mcpServers) {
+          delete mcpServers[MCP_SERVER_KEY2];
+          writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check whether CLEO is installed in the Codex CLI environment.
+   *
+   * Checks for MCP server registered in ~/.codex/config.json.
+   * Returns true if the CLEO MCP server entry is found.
+   * @task T162
+   */
+  async isInstalled() {
+    const configPath = join8(homedir6(), ".codex", "config.json");
+    if (existsSync5(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+        const mcpServers = config.mcpServers;
+        if (mcpServers && MCP_SERVER_KEY2 in mcpServers) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Ensure AGENTS.md contains @-references to CLEO instruction files.
+   *
+   * Creates AGENTS.md if it does not exist. Appends any missing references.
+   *
+   * @param projectDir - Project root directory
+   * @task T162
+   */
+  async ensureInstructionReferences(projectDir) {
+    this.updateInstructionFile(projectDir);
+  }
+  /**
+   * Register the CLEO MCP server in ~/.codex/config.json.
+   *
+   * Codex CLI stores its MCP server configuration in ~/.codex/config.json
+   * under the mcpServers key.
+   *
+   * @param mcpServerPath - Absolute path to the MCP server entry point
+   * @returns true if registration was performed or updated
+   */
+  registerMcpServer(mcpServerPath) {
+    const codexDir = join8(homedir6(), ".codex");
+    const configPath = join8(codexDir, "config.json");
+    let config = {};
+    mkdirSync2(codexDir, { recursive: true });
+    if (existsSync5(configPath)) {
+      try {
+        config = JSON.parse(readFileSync4(configPath, "utf-8"));
+      } catch {
+      }
+    }
+    if (!config.mcpServers || typeof config.mcpServers !== "object") {
+      config.mcpServers = {};
+    }
+    const mcpServers = config.mcpServers;
+    mcpServers[MCP_SERVER_KEY2] = {
+      command: "node",
+      args: [mcpServerPath]
+    };
+    writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+  }
+  /**
+   * Update AGENTS.md with CLEO @-references.
+   *
+   * @param projectDir - Project root directory
+   * @returns true if the file was created or modified
+   */
+  updateInstructionFile(projectDir) {
+    const agentsMdPath = join8(projectDir, "AGENTS.md");
+    let content = "";
+    let existed = false;
+    if (existsSync5(agentsMdPath)) {
+      content = readFileSync4(agentsMdPath, "utf-8");
+      existed = true;
+    }
+    const missingRefs = INSTRUCTION_REFERENCES2.filter((ref) => !content.includes(ref));
+    if (missingRefs.length === 0) {
+      return false;
+    }
+    const refsBlock = missingRefs.join("\n");
+    if (existed) {
+      const separator = content.endsWith("\n") ? "" : "\n";
+      content = content + separator + refsBlock + "\n";
+    } else {
+      content = refsBlock + "\n";
+    }
+    writeFileSync3(agentsMdPath, content, "utf-8");
+    return true;
+  }
+};
+
+// packages/adapters/src/providers/codex/adapter.ts
+var execAsync3 = promisify3(exec3);
+var CodexAdapter = class {
+  id = "codex";
+  name = "Codex";
+  version = "1.0.0";
+  capabilities = {
+    supportsHooks: true,
+    supportedHookEvents: ["SessionStart", "UserPromptSubmit", "Stop"],
+    supportsSpawn: false,
+    supportsInstall: true,
+    supportsMcp: true,
+    supportsInstructionFiles: false,
+    supportsContextMonitor: false,
+    supportsStatusline: false,
+    supportsProviderPaths: false,
+    supportsTransport: false,
+    supportsTaskSync: false
+  };
+  hooks;
+  install;
+  projectDir = null;
+  initialized = false;
+  constructor() {
+    this.hooks = new CodexHookProvider();
+    this.install = new CodexInstallProvider();
+  }
+  /**
+   * Initialize the adapter for a given project directory.
+   *
+   * @param projectDir - Root directory of the project
+   * @task T162
+   */
+  async initialize(projectDir) {
+    this.projectDir = projectDir;
+    this.initialized = true;
+  }
+  /**
+   * Dispose the adapter and clean up resources.
+   *
+   * Unregisters hooks and releases any tracked state.
+   * @task T162
+   */
+  async dispose() {
+    if (this.hooks.isRegistered()) {
+      await this.hooks.unregisterNativeHooks();
+    }
+    this.initialized = false;
+    this.projectDir = null;
+  }
+  /**
+   * Run a health check to verify Codex CLI is accessible.
+   *
+   * Checks:
+   * 1. Adapter has been initialized
+   * 2. Codex CLI binary is available in PATH
+   * 3. ~/.codex/ configuration directory exists
+   *
+   * @returns Health status with details about each check
+   * @task T162
+   */
+  async healthCheck() {
+    const details = {};
+    if (!this.initialized) {
+      return {
+        healthy: false,
+        provider: this.id,
+        details: { error: "Adapter not initialized" }
+      };
+    }
+    let cliAvailable = false;
+    try {
+      const { stdout } = await execAsync3("which codex");
+      cliAvailable = stdout.trim().length > 0;
+      details.cliPath = stdout.trim();
+    } catch {
+      details.cliAvailable = false;
+    }
+    const codexConfigDir = join9(homedir7(), ".codex");
+    const configExists = existsSync6(codexConfigDir);
+    details.configDirExists = configExists;
+    const healthy = cliAvailable;
+    details.cliAvailable = cliAvailable;
+    return {
+      healthy,
+      provider: this.id,
+      details
+    };
+  }
+  /**
+   * Check whether the adapter has been initialized.
+   * @task T162
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get the project directory this adapter was initialized with.
+   * @task T162
+   */
+  getProjectDir() {
+    return this.projectDir;
+  }
+};
+
+// packages/adapters/src/providers/codex/index.ts
+function createAdapter2() {
+  return new CodexAdapter();
+}
+
+// packages/adapters/src/index.ts
 init_cursor();
+
+// packages/adapters/src/providers/gemini-cli/adapter.ts
+import { exec as exec4 } from "node:child_process";
+import { existsSync as existsSync10 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join14 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+
+// packages/adapters/src/providers/gemini-cli/hooks.ts
+import { readdir as readdir2, readFile as readFile3 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+var GEMINI_CLI_EVENT_MAP = {
+  SessionStart: "SessionStart",
+  SessionEnd: "SessionEnd",
+  PromptSubmit: "BeforeAgent",
+  ResponseComplete: "AfterAgent",
+  PreToolUse: "BeforeTool",
+  PostToolUse: "AfterTool",
+  PreModel: "BeforeModel",
+  PostModel: "AfterModel",
+  PreCompact: "PreCompress",
+  Notification: "Notification"
+};
+var GeminiCliHookProvider = class {
+  registered = false;
+  /**
+   * Map a Gemini CLI native event name to a CAAMP hook event name.
+   *
+   * @param providerEvent - Gemini CLI event name (e.g. "SessionStart", "PreToolUse")
+   * @returns CAAMP event name or null if unmapped
+   * @task T161
+   */
+  mapProviderEvent(providerEvent) {
+    return GEMINI_CLI_EVENT_MAP[providerEvent] ?? null;
+  }
+  /**
+   * Register native hooks for a project.
+   *
+   * For Gemini CLI, hooks are registered via the config system
+   * (~/.gemini/), which is handled by the install provider.
+   * This method marks hooks as registered without performing
+   * filesystem operations.
+   *
+   * @param _projectDir - Project directory (unused; hooks are global)
+   * @task T161
+   */
+  async registerNativeHooks(_projectDir) {
+    this.registered = true;
+  }
+  /**
+   * Unregister native hooks.
+   *
+   * For Gemini CLI, this is a no-op since hooks are managed through
+   * the config system. Unregistration happens via the install
+   * provider's uninstall method.
+   * @task T161
+   */
+  async unregisterNativeHooks() {
+    this.registered = false;
+  }
+  /**
+   * Check whether hooks have been registered via registerNativeHooks.
+   * @task T161
+   */
+  isRegistered() {
+    return this.registered;
+  }
+  /**
+   * Get the full event mapping for introspection/debugging.
+   * @task T161
+   */
+  getEventMap() {
+    return { ...GEMINI_CLI_EVENT_MAP };
+  }
+  /**
+   * Extract a plain-text transcript from Gemini CLI session data.
+   *
+   * Reads the most recent session file under ~/.gemini/ and extracts
+   * turn text into a flat string for brain observation extraction.
+   *
+   * Returns null when no session data is found or on any read error.
+   *
+   * @param _sessionId - CLEO session ID (unused; reads the most recent file)
+   * @param _projectDir - Project directory (unused; Gemini CLI uses global paths)
+   * @task T161 @epic T134
+   */
+  async getTranscript(_sessionId, _projectDir) {
+    try {
+      const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "/root";
+      const geminiDir = join12(homeDir, ".gemini");
+      let allFiles = [];
+      try {
+        const entries = await readdir2(geminiDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isFile()) continue;
+          const name = entry.name;
+          if (name.endsWith(".json") || name.endsWith(".jsonl")) {
+            allFiles.push(join12(geminiDir, name));
+          }
+        }
+      } catch {
+        return null;
+      }
+      if (allFiles.length === 0) return null;
+      allFiles = allFiles.sort((a, b) => b.localeCompare(a));
+      const mostRecent = allFiles[0];
+      if (!mostRecent) return null;
+      const raw = await readFile3(mostRecent, "utf-8");
+      const turns = [];
+      const lines = raw.split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          const role = entry.role;
+          const content = entry.content;
+          if (role === "assistant" && typeof content === "string") {
+            turns.push(`assistant: ${content}`);
+          } else if (role === "user" && typeof content === "string") {
+            turns.push(`user: ${content}`);
+          }
+        } catch {
+        }
+      }
+      return turns.length > 0 ? turns.join("\n") : null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// packages/adapters/src/providers/gemini-cli/install.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join13 } from "node:path";
+var INSTRUCTION_REFERENCES4 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+var MCP_SERVER_KEY4 = "cleo";
+var GeminiCliInstallProvider = class {
+  /**
+   * Install CLEO into a Gemini CLI environment.
+   *
+   * @param options - Installation options including project directory and MCP server path
+   * @returns Result describing what was installed
+   * @task T161
+   */
+  async install(options) {
+    const { projectDir, mcpServerPath } = options;
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let instructionFileUpdated = false;
+    let mcpRegistered = false;
+    const details = {};
+    if (mcpServerPath) {
+      mcpRegistered = this.registerMcpServer(mcpServerPath);
+      if (mcpRegistered) {
+        details.mcpConfigPath = join13(homedir8(), ".gemini", "settings.json");
+      }
+    }
+    instructionFileUpdated = this.updateInstructionFile(projectDir);
+    if (instructionFileUpdated) {
+      details.instructionFile = join13(projectDir, "AGENTS.md");
+    }
+    return {
+      success: true,
+      installedAt,
+      instructionFileUpdated,
+      mcpRegistered,
+      details
+    };
+  }
+  /**
+   * Uninstall CLEO from the Gemini CLI environment.
+   *
+   * Removes the MCP server registration from ~/.gemini/settings.json.
+   * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+   * @task T161
+   */
+  async uninstall() {
+    const settingsPath = join13(homedir8(), ".gemini", "settings.json");
+    if (existsSync9(settingsPath)) {
+      try {
+        const raw = readFileSync6(settingsPath, "utf-8");
+        const config = JSON.parse(raw);
+        const mcpServers = config.mcpServers;
+        if (mcpServers && MCP_SERVER_KEY4 in mcpServers) {
+          delete mcpServers[MCP_SERVER_KEY4];
+          writeFileSync5(settingsPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check whether CLEO is installed in the Gemini CLI environment.
+   *
+   * Checks for MCP server registered in ~/.gemini/settings.json.
+   * Returns true if the CLEO MCP server entry is found.
+   * @task T161
+   */
+  async isInstalled() {
+    const settingsPath = join13(homedir8(), ".gemini", "settings.json");
+    if (existsSync9(settingsPath)) {
+      try {
+        const config = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+        const mcpServers = config.mcpServers;
+        if (mcpServers && MCP_SERVER_KEY4 in mcpServers) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Ensure AGENTS.md contains @-references to CLEO instruction files.
+   *
+   * Creates AGENTS.md if it does not exist. Appends any missing references.
+   *
+   * @param projectDir - Project root directory
+   * @task T161
+   */
+  async ensureInstructionReferences(projectDir) {
+    this.updateInstructionFile(projectDir);
+  }
+  /**
+   * Register the CLEO MCP server in ~/.gemini/settings.json.
+   *
+   * Gemini CLI stores its MCP server configuration in ~/.gemini/settings.json
+   * under the mcpServers key.
+   *
+   * @param mcpServerPath - Absolute path to the MCP server entry point
+   * @returns true if registration was performed or updated
+   */
+  registerMcpServer(mcpServerPath) {
+    const geminiDir = join13(homedir8(), ".gemini");
+    const settingsPath = join13(geminiDir, "settings.json");
+    let config = {};
+    mkdirSync4(geminiDir, { recursive: true });
+    if (existsSync9(settingsPath)) {
+      try {
+        config = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+      } catch {
+      }
+    }
+    if (!config.mcpServers || typeof config.mcpServers !== "object") {
+      config.mcpServers = {};
+    }
+    const mcpServers = config.mcpServers;
+    mcpServers[MCP_SERVER_KEY4] = {
+      command: "node",
+      args: [mcpServerPath]
+    };
+    writeFileSync5(settingsPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+  }
+  /**
+   * Update AGENTS.md with CLEO @-references.
+   *
+   * @param projectDir - Project root directory
+   * @returns true if the file was created or modified
+   */
+  updateInstructionFile(projectDir) {
+    const agentsMdPath = join13(projectDir, "AGENTS.md");
+    let content = "";
+    let existed = false;
+    if (existsSync9(agentsMdPath)) {
+      content = readFileSync6(agentsMdPath, "utf-8");
+      existed = true;
+    }
+    const missingRefs = INSTRUCTION_REFERENCES4.filter((ref) => !content.includes(ref));
+    if (missingRefs.length === 0) {
+      return false;
+    }
+    const refsBlock = missingRefs.join("\n");
+    if (existed) {
+      const separator = content.endsWith("\n") ? "" : "\n";
+      content = content + separator + refsBlock + "\n";
+    } else {
+      content = refsBlock + "\n";
+    }
+    writeFileSync5(agentsMdPath, content, "utf-8");
+    return true;
+  }
+};
+
+// packages/adapters/src/providers/gemini-cli/adapter.ts
+var execAsync4 = promisify4(exec4);
+var GeminiCliAdapter = class {
+  id = "gemini-cli";
+  name = "Gemini CLI";
+  version = "1.0.0";
+  capabilities = {
+    supportsHooks: true,
+    supportedHookEvents: [
+      "SessionStart",
+      "SessionEnd",
+      "BeforeAgent",
+      "AfterAgent",
+      "BeforeTool",
+      "AfterTool",
+      "BeforeModel",
+      "AfterModel",
+      "PreCompress",
+      "Notification"
+    ],
+    supportsSpawn: false,
+    supportsInstall: true,
+    supportsMcp: true,
+    supportsInstructionFiles: false,
+    supportsContextMonitor: false,
+    supportsStatusline: false,
+    supportsProviderPaths: false,
+    supportsTransport: false,
+    supportsTaskSync: false
+  };
+  hooks;
+  install;
+  projectDir = null;
+  initialized = false;
+  constructor() {
+    this.hooks = new GeminiCliHookProvider();
+    this.install = new GeminiCliInstallProvider();
+  }
+  /**
+   * Initialize the adapter for a given project directory.
+   *
+   * @param projectDir - Root directory of the project
+   * @task T161
+   */
+  async initialize(projectDir) {
+    this.projectDir = projectDir;
+    this.initialized = true;
+  }
+  /**
+   * Dispose the adapter and clean up resources.
+   *
+   * Unregisters hooks and releases any tracked state.
+   * @task T161
+   */
+  async dispose() {
+    if (this.hooks.isRegistered()) {
+      await this.hooks.unregisterNativeHooks();
+    }
+    this.initialized = false;
+    this.projectDir = null;
+  }
+  /**
+   * Run a health check to verify Gemini CLI is accessible.
+   *
+   * Checks:
+   * 1. Adapter has been initialized
+   * 2. Gemini CLI binary is available in PATH
+   * 3. ~/.gemini/ configuration directory exists
+   *
+   * @returns Health status with details about each check
+   * @task T161
+   */
+  async healthCheck() {
+    const details = {};
+    if (!this.initialized) {
+      return {
+        healthy: false,
+        provider: this.id,
+        details: { error: "Adapter not initialized" }
+      };
+    }
+    let cliAvailable = false;
+    try {
+      const { stdout } = await execAsync4("which gemini");
+      cliAvailable = stdout.trim().length > 0;
+      details.cliPath = stdout.trim();
+    } catch {
+      details.cliAvailable = false;
+    }
+    const geminiConfigDir = join14(homedir9(), ".gemini");
+    const configExists = existsSync10(geminiConfigDir);
+    details.configDirExists = configExists;
+    const healthy = cliAvailable;
+    details.cliAvailable = cliAvailable;
+    return {
+      healthy,
+      provider: this.id,
+      details
+    };
+  }
+  /**
+   * Check whether the adapter has been initialized.
+   * @task T161
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get the project directory this adapter was initialized with.
+   * @task T161
+   */
+  getProjectDir() {
+    return this.projectDir;
+  }
+};
+
+// packages/adapters/src/providers/gemini-cli/index.ts
+function createAdapter4() {
+  return new GeminiCliAdapter();
+}
+
+// packages/adapters/src/providers/kimi/adapter.ts
+import { exec as exec5 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join16 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+
+// packages/adapters/src/providers/kimi/hooks.ts
+var KimiHookProvider = class {
+  registered = false;
+  /**
+   * Map a Kimi native event name to a CAAMP hook event name.
+   *
+   * Kimi has no hook system, so this always returns null.
+   *
+   * @param _providerEvent - Unused; Kimi emits no hookable events
+   * @returns Always null
+   * @task T163
+   */
+  mapProviderEvent(_providerEvent) {
+    return null;
+  }
+  /**
+   * Register native hooks for a project.
+   *
+   * Kimi has no hook system. This method is a no-op and only
+   * tracks registration state for interface compliance.
+   *
+   * @param _projectDir - Project directory (unused)
+   * @task T163
+   */
+  async registerNativeHooks(_projectDir) {
+    this.registered = true;
+  }
+  /**
+   * Unregister native hooks.
+   *
+   * Kimi has no hook system. This method is a no-op.
+   * @task T163
+   */
+  async unregisterNativeHooks() {
+    this.registered = false;
+  }
+  /**
+   * Check whether hooks have been registered via registerNativeHooks.
+   * @task T163
+   */
+  isRegistered() {
+    return this.registered;
+  }
+  /**
+   * Get the full event mapping for introspection/debugging.
+   *
+   * Returns an empty map since Kimi has no hookable events.
+   * @task T163
+   */
+  getEventMap() {
+    return {};
+  }
+};
+
+// packages/adapters/src/providers/kimi/install.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join15 } from "node:path";
+var INSTRUCTION_REFERENCES5 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+var MCP_SERVER_KEY5 = "cleo";
+var KimiInstallProvider = class {
+  /**
+   * Install CLEO into a Kimi environment.
+   *
+   * @param options - Installation options including project directory and MCP server path
+   * @returns Result describing what was installed
+   * @task T163
+   */
+  async install(options) {
+    const { projectDir, mcpServerPath } = options;
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let instructionFileUpdated = false;
+    let mcpRegistered = false;
+    const details = {};
+    if (mcpServerPath) {
+      mcpRegistered = this.registerMcpServer(mcpServerPath);
+      if (mcpRegistered) {
+        details.mcpConfigPath = join15(homedir10(), ".kimi", "mcp.json");
+      }
+    }
+    instructionFileUpdated = this.updateInstructionFile(projectDir);
+    if (instructionFileUpdated) {
+      details.instructionFile = join15(projectDir, "AGENTS.md");
+    }
+    return {
+      success: true,
+      installedAt,
+      instructionFileUpdated,
+      mcpRegistered,
+      details
+    };
+  }
+  /**
+   * Uninstall CLEO from the Kimi environment.
+   *
+   * Removes the MCP server registration from ~/.kimi/mcp.json.
+   * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+   * @task T163
+   */
+  async uninstall() {
+    const mcpPath = join15(homedir10(), ".kimi", "mcp.json");
+    if (existsSync11(mcpPath)) {
+      try {
+        const raw = readFileSync7(mcpPath, "utf-8");
+        const config = JSON.parse(raw);
+        const mcpServers = config.mcpServers;
+        if (mcpServers && MCP_SERVER_KEY5 in mcpServers) {
+          delete mcpServers[MCP_SERVER_KEY5];
+          writeFileSync6(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check whether CLEO is installed in the Kimi environment.
+   *
+   * Checks for MCP server registered in ~/.kimi/mcp.json.
+   * Returns true if the CLEO MCP server entry is found.
+   * @task T163
+   */
+  async isInstalled() {
+    const mcpPath = join15(homedir10(), ".kimi", "mcp.json");
+    if (existsSync11(mcpPath)) {
+      try {
+        const config = JSON.parse(readFileSync7(mcpPath, "utf-8"));
+        const mcpServers = config.mcpServers;
+        if (mcpServers && MCP_SERVER_KEY5 in mcpServers) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Ensure AGENTS.md contains @-references to CLEO instruction files.
+   *
+   * Creates AGENTS.md if it does not exist. Appends any missing references.
+   *
+   * @param projectDir - Project root directory
+   * @task T163
+   */
+  async ensureInstructionReferences(projectDir) {
+    this.updateInstructionFile(projectDir);
+  }
+  /**
+   * Register the CLEO MCP server in ~/.kimi/mcp.json.
+   *
+   * Kimi stores its MCP server configuration in ~/.kimi/mcp.json
+   * under the mcpServers key.
+   *
+   * @param mcpServerPath - Absolute path to the MCP server entry point
+   * @returns true if registration was performed or updated
+   */
+  registerMcpServer(mcpServerPath) {
+    const kimiDir = join15(homedir10(), ".kimi");
+    const mcpPath = join15(kimiDir, "mcp.json");
+    let config = {};
+    mkdirSync5(kimiDir, { recursive: true });
+    if (existsSync11(mcpPath)) {
+      try {
+        config = JSON.parse(readFileSync7(mcpPath, "utf-8"));
+      } catch {
+      }
+    }
+    if (!config.mcpServers || typeof config.mcpServers !== "object") {
+      config.mcpServers = {};
+    }
+    const mcpServers = config.mcpServers;
+    mcpServers[MCP_SERVER_KEY5] = {
+      command: "node",
+      args: [mcpServerPath]
+    };
+    writeFileSync6(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return true;
+  }
+  /**
+   * Update AGENTS.md with CLEO @-references.
+   *
+   * @param projectDir - Project root directory
+   * @returns true if the file was created or modified
+   */
+  updateInstructionFile(projectDir) {
+    const agentsMdPath = join15(projectDir, "AGENTS.md");
+    let content = "";
+    let existed = false;
+    if (existsSync11(agentsMdPath)) {
+      content = readFileSync7(agentsMdPath, "utf-8");
+      existed = true;
+    }
+    const missingRefs = INSTRUCTION_REFERENCES5.filter((ref) => !content.includes(ref));
+    if (missingRefs.length === 0) {
+      return false;
+    }
+    const refsBlock = missingRefs.join("\n");
+    if (existed) {
+      const separator = content.endsWith("\n") ? "" : "\n";
+      content = content + separator + refsBlock + "\n";
+    } else {
+      content = refsBlock + "\n";
+    }
+    writeFileSync6(agentsMdPath, content, "utf-8");
+    return true;
+  }
+};
+
+// packages/adapters/src/providers/kimi/adapter.ts
+var execAsync5 = promisify5(exec5);
+var KimiAdapter = class {
+  id = "kimi";
+  name = "Kimi";
+  version = "1.0.0";
+  capabilities = {
+    supportsHooks: false,
+    supportedHookEvents: [],
+    supportsSpawn: false,
+    supportsInstall: true,
+    supportsMcp: true,
+    supportsInstructionFiles: false,
+    supportsContextMonitor: false,
+    supportsStatusline: false,
+    supportsProviderPaths: false,
+    supportsTransport: false,
+    supportsTaskSync: false
+  };
+  hooks;
+  install;
+  projectDir = null;
+  initialized = false;
+  constructor() {
+    this.hooks = new KimiHookProvider();
+    this.install = new KimiInstallProvider();
+  }
+  /**
+   * Initialize the adapter for a given project directory.
+   *
+   * @param projectDir - Root directory of the project
+   * @task T163
+   */
+  async initialize(projectDir) {
+    this.projectDir = projectDir;
+    this.initialized = true;
+  }
+  /**
+   * Dispose the adapter and clean up resources.
+   *
+   * Releases tracked state. No hooks to unregister since Kimi
+   * has no native hook system.
+   * @task T163
+   */
+  async dispose() {
+    this.initialized = false;
+    this.projectDir = null;
+  }
+  /**
+   * Run a health check to verify Kimi is accessible.
+   *
+   * Checks:
+   * 1. Adapter has been initialized
+   * 2. Kimi CLI binary is available in PATH
+   * 3. ~/.kimi/ configuration directory exists
+   *
+   * @returns Health status with details about each check
+   * @task T163
+   */
+  async healthCheck() {
+    const details = {};
+    if (!this.initialized) {
+      return {
+        healthy: false,
+        provider: this.id,
+        details: { error: "Adapter not initialized" }
+      };
+    }
+    let cliAvailable = false;
+    try {
+      const { stdout } = await execAsync5("which kimi");
+      cliAvailable = stdout.trim().length > 0;
+      details.cliPath = stdout.trim();
+    } catch {
+      details.cliAvailable = false;
+    }
+    const kimiConfigDir = join16(homedir11(), ".kimi");
+    const configExists = existsSync12(kimiConfigDir);
+    details.configDirExists = configExists;
+    const healthy = cliAvailable;
+    details.cliAvailable = cliAvailable;
+    return {
+      healthy,
+      provider: this.id,
+      details
+    };
+  }
+  /**
+   * Check whether the adapter has been initialized.
+   * @task T163
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get the project directory this adapter was initialized with.
+   * @task T163
+   */
+  getProjectDir() {
+    return this.projectDir;
+  }
+};
+
+// packages/adapters/src/providers/kimi/index.ts
+function createAdapter5() {
+  return new KimiAdapter();
+}
+
+// packages/adapters/src/index.ts
 init_opencode();
 
 // packages/adapters/src/registry.js
-import { readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname2, join as join12, resolve } from "node:path";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname2, join as join20, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 var PROVIDER_IDS = ["claude-code", "opencode", "cursor"];
 function getProviderManifests() {
@@ -2009,8 +3123,8 @@ function getProviderManifests() {
   const baseDir = resolve(dirname2(fileURLToPath(import.meta.url)), "providers");
   for (const providerId of PROVIDER_IDS) {
     try {
-      const manifestPath = join12(baseDir, providerId, "manifest.json");
-      const raw = readFileSync6(manifestPath, "utf-8");
+      const manifestPath = join20(baseDir, providerId, "manifest.json");
+      const raw = readFileSync9(manifestPath, "utf-8");
       manifests.push(JSON.parse(raw));
     } catch {
     }
@@ -2041,17 +3155,29 @@ export {
   ClaudeCodePathProvider,
   ClaudeCodeSpawnProvider,
   ClaudeCodeTransportProvider,
+  CodexAdapter,
+  CodexHookProvider,
+  CodexInstallProvider,
   CursorAdapter,
   CursorHookProvider,
   CursorInstallProvider,
+  GeminiCliAdapter,
+  GeminiCliHookProvider,
+  GeminiCliInstallProvider,
+  KimiAdapter,
+  KimiHookProvider,
+  KimiInstallProvider,
   OpenCodeAdapter,
   OpenCodeHookProvider,
   OpenCodeInstallProvider,
   OpenCodeSpawnProvider,
   checkStatuslineIntegration,
   createAdapter as createClaudeCodeAdapter,
-  createAdapter2 as createCursorAdapter,
-  createAdapter3 as createOpenCodeAdapter,
+  createAdapter2 as createCodexAdapter,
+  createAdapter3 as createCursorAdapter,
+  createAdapter4 as createGeminiCliAdapter,
+  createAdapter5 as createKimiAdapter,
+  createAdapter6 as createOpenCodeAdapter,
   discoverProviders,
   getProviderManifests,
   getSetupInstructions,