@cleocode/adapters 2026.4.13 → 2026.4.14

package/dist/index.js

@@ -0,0 +1,3246 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/adapters/src/providers/claude-code/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ClaudeCodePathProvider;
+var init_paths = __esm({
+  "packages/adapters/src/providers/claude-code/paths.ts"() {
+    "use strict";
+    ClaudeCodePathProvider = class {
+      /** Get the provider's root configuration directory. */
+      getProviderDir() {
+        return process.env["CLAUDE_HOME"] ?? join(homedir(), ".claude");
+      }
+      /** Get the path to the provider's settings file, or null if unavailable. */
+      getSettingsPath() {
+        return process.env["CLAUDE_SETTINGS"] ?? join(this.getProviderDir(), "settings.json");
+      }
+      /** Get the directory where agents are installed, or null if unsupported. */
+      getAgentInstallDir() {
+        return join(this.getProviderDir(), "agents");
+      }
+      /** Get the path to the provider's memory database, or null if unsupported. */
+      getMemoryDbPath() {
+        return process.env["CLAUDE_MEM_DB"] ?? join(homedir(), ".claude-mem", "claude-mem.db");
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/context-monitor.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
+function getContextStatusFromPercentage(percentage) {
+  if (percentage >= THRESHOLDS.EMERGENCY) return "emergency";
+  if (percentage >= THRESHOLDS.CRITICAL) return "critical";
+  if (percentage >= THRESHOLDS.CAUTION) return "caution";
+  if (percentage >= THRESHOLDS.WARNING) return "warning";
+  return "ok";
+}
+var THRESHOLDS, ClaudeCodeContextMonitorProvider;
+var init_context_monitor = __esm({
+  "packages/adapters/src/providers/claude-code/context-monitor.ts"() {
+    "use strict";
+    init_paths();
+    THRESHOLDS = {
+      WARNING: 50,
+      CAUTION: 70,
+      CRITICAL: 85,
+      EMERGENCY: 95
+    };
+    ClaudeCodeContextMonitorProvider = class {
+      /** Path provider for resolving Claude Code directory locations. */
+      pathProvider = new ClaudeCodePathProvider();
+      /** Process raw context window JSON and return a formatted summary string. */
+      async processContextInput(input, cwd) {
+        const typed = input;
+        const contextSize = typed.context_window?.context_window_size ?? 2e5;
+        const usage = typed.context_window?.current_usage;
+        if (!usage) return "-- no data";
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheCreate = usage.cache_creation_input_tokens ?? 0;
+        const totalTokens = inputTokens + outputTokens + cacheCreate;
+        const percentage = Math.floor(totalTokens * 100 / contextSize);
+        const status = getContextStatusFromPercentage(percentage);
+        const cleoDir = cwd ? join2(cwd, ".cleo") : ".cleo";
+        if (existsSync(cleoDir)) {
+          const stateDir = join2(cleoDir, "context-states");
+          const statePath = join2(stateDir, ".context-state.json");
+          const state = {
+            $schema: "https://cleo-dev.com/schemas/v1/context-state.schema.json",
+            version: "1.0.0",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+            staleAfterMs: 5e3,
+            contextWindow: {
+              maxTokens: contextSize,
+              currentTokens: totalTokens,
+              percentage,
+              breakdown: {
+                inputTokens,
+                outputTokens,
+                cacheCreationTokens: cacheCreate,
+                cacheReadTokens: usage.cache_read_input_tokens ?? 0
+              }
+            },
+            thresholds: {
+              warning: THRESHOLDS.WARNING,
+              caution: THRESHOLDS.CAUTION,
+              critical: THRESHOLDS.CRITICAL,
+              emergency: THRESHOLDS.EMERGENCY
+            },
+            status,
+            cleoSessionId: ""
+          };
+          try {
+            await mkdir(dirname(statePath), { recursive: true });
+            writeFileSync(statePath, JSON.stringify(state, null, 2));
+          } catch {
+          }
+        }
+        return `${percentage}% | ${totalTokens}/${contextSize}`;
+      }
+      /** Check the current statusline integration status in Claude Code settings. */
+      checkStatuslineIntegration() {
+        const settingsPath = this.pathProvider.getSettingsPath();
+        if (!settingsPath || !existsSync(settingsPath)) return "no_settings";
+        try {
+          const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+          const statusLine = settings.statusLine;
+          if (!statusLine?.type) return "not_configured";
+          if (statusLine.type !== "command") return "custom_no_cleo";
+          const cmd = statusLine.command ?? "";
+          if (cmd.includes("context-monitor.sh") || cmd.includes("cleo-statusline") || cmd.includes(".context-state.json") || cmd.includes("context-states")) {
+            return "configured";
+          }
+          const scriptPath = cmd.startsWith("~") ? cmd.replace("~", homedir2()) : cmd;
+          if (existsSync(scriptPath)) {
+            try {
+              const content = readFileSync(scriptPath, "utf-8");
+              if (content.includes("context-state.json")) return "configured";
+            } catch {
+            }
+          }
+          return "custom_no_cleo";
+        } catch {
+          return "no_settings";
+        }
+      }
+      /** Get the recommended statusline configuration object for Claude Code settings. */
+      getStatuslineConfig() {
+        return {
+          statusLine: {
+            type: "command",
+            command: join2(homedir2(), ".cleo", "lib", "session", "context-monitor.sh")
+          }
+        };
+      }
+      /** Get human-readable setup instructions for enabling context monitoring. */
+      getSetupInstructions() {
+        const settingsPath = this.pathProvider.getSettingsPath() ?? "~/.claude/settings.json";
+        return [
+          "To enable context monitoring, add to your Claude Code settings:",
+          `File: ${settingsPath}`,
+          "",
+          JSON.stringify(this.getStatuslineConfig(), null, 2),
+          "",
+          "This enables real-time context window tracking in the CLI."
+        ].join("\n");
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/hooks.ts
+import { readdir, readFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var PROVIDER_ID, CLAUDE_CODE_EVENT_MAP, ClaudeCodeHookProvider;
+var init_hooks = __esm({
+  "packages/adapters/src/providers/claude-code/hooks.ts"() {
+    "use strict";
+    PROVIDER_ID = "claude-code";
+    CLAUDE_CODE_EVENT_MAP = {
+      // CAAMP: toNative('SessionStart',      'claude-code') = 'SessionStart'
+      SessionStart: "SessionStart",
+      // CAAMP: toNative('SessionEnd',        'claude-code') = 'SessionEnd'
+      SessionEnd: "SessionEnd",
+      // CAAMP: toNative('PromptSubmit',      'claude-code') = 'UserPromptSubmit'
+      UserPromptSubmit: "PromptSubmit",
+      // CAAMP: toNative('ResponseComplete',  'claude-code') = 'Stop'
+      Stop: "ResponseComplete",
+      // CAAMP: toNative('PreToolUse',        'claude-code') = 'PreToolUse'
+      PreToolUse: "PreToolUse",
+      // CAAMP: toNative('PostToolUse',       'claude-code') = 'PostToolUse'
+      PostToolUse: "PostToolUse",
+      // CAAMP: toNative('PostToolUseFailure','claude-code') = 'PostToolUseFailure'
+      PostToolUseFailure: "PostToolUseFailure",
+      // CAAMP: toNative('PermissionRequest', 'claude-code') = 'PermissionRequest'
+      PermissionRequest: "PermissionRequest",
+      // CAAMP: toNative('SubagentStart',     'claude-code') = 'SubagentStart'
+      SubagentStart: "SubagentStart",
+      // CAAMP: toNative('SubagentStop',      'claude-code') = 'SubagentStop'
+      SubagentStop: "SubagentStop",
+      // CAAMP: toNative('PreCompact',        'claude-code') = 'PreCompact'
+      PreCompact: "PreCompact",
+      // CAAMP: toNative('PostCompact',       'claude-code') = 'PostCompact'
+      PostCompact: "PostCompact",
+      // CAAMP: toNative('Notification',      'claude-code') = 'Notification'
+      Notification: "Notification",
+      // CAAMP: toNative('ConfigChange',      'claude-code') = 'ConfigChange'
+      ConfigChange: "ConfigChange"
+    };
+    ClaudeCodeHookProvider = class {
+      /** Whether hooks have been registered for the current session. */
+      registered = false;
+      /**
+       * Map a Claude Code native event name to a CAAMP canonical hook event name.
+       *
+       * Looks up the native event name in the map derived from
+       * `getProviderHookProfile('claude-code').mappings` (CAAMP 1.9.1).
+       * Returns null for unrecognised events (e.g. PreModel, PostModel which
+       * Claude Code does not support).
+       *
+       * @param providerEvent - Claude Code native event (e.g. "UserPromptSubmit", "Stop")
+       * @returns CAAMP canonical event name, or null if unmapped
+       * @task T164
+       */
+      mapProviderEvent(providerEvent) {
+        return CLAUDE_CODE_EVENT_MAP[providerEvent] ?? null;
+      }
+      /**
+       * Register native hooks for a project.
+       *
+       * For Claude Code, hooks are registered via the config system
+       * (`~/.claude/settings.json`), managed by the install provider.
+       * This method marks hooks as registered without performing filesystem operations.
+       *
+       * Iterating supported events is handled at install time using
+       * `getSupportedCanonicalEvents()` to enumerate all 14 supported hooks.
+       *
+       * @param _projectDir - Project directory (unused; Claude Code uses global config)
+       * @task T164
+       */
+      async registerNativeHooks(_projectDir) {
+        this.registered = true;
+      }
+      /**
+       * Unregister native hooks.
+       *
+       * For Claude Code, this is a no-op since hooks are managed through the config
+       * system. Unregistration happens via the install provider's uninstall method.
+       *
+       * @task T164
+       */
+      async unregisterNativeHooks() {
+        this.registered = false;
+      }
+      /**
+       * Check whether hooks have been registered via `registerNativeHooks`.
+       */
+      isRegistered() {
+        return this.registered;
+      }
+      /**
+       * Get the native→canonical event mapping for introspection and debugging.
+       *
+       * Returns the map derived from `getProviderHookProfile('claude-code').mappings`
+       * (CAAMP 1.9.1). Use `getSupportedCanonicalEvents()` to enumerate canonical
+       * names via live CAAMP APIs.
+       *
+       * @returns Immutable record of native event name → canonical event name
+       */
+      getEventMap() {
+        return { ...CLAUDE_CODE_EVENT_MAP };
+      }
+      /**
+       * Enumerate supported canonical events via CAAMP's `getSupportedEvents()`.
+       *
+       * Calls `getSupportedEvents('claude-code')` from the CAAMP normalizer to
+       * get the authoritative list. Claude Code supports 14 of 16 canonical events
+       * (PreModel and PostModel are not supported). Falls back to the values of
+       * the static event map when CAAMP is unavailable at runtime.
+       *
+       * @returns Array of CAAMP canonical event names supported by Claude Code
+       * @task T164
+       */
+      async getSupportedCanonicalEvents() {
+        try {
+          const { getSupportedEvents } = await import("@cleocode/caamp");
+          return getSupportedEvents(PROVIDER_ID);
+        } catch {
+          return [...new Set(Object.values(CLAUDE_CODE_EVENT_MAP))];
+        }
+      }
+      /**
+       * Retrieve the full provider hook profile from CAAMP.
+       *
+       * Calls `getProviderHookProfile('claude-code')` from the CAAMP normalizer to
+       * get the complete profile: hook system type (`config`), config path
+       * (`~/.claude/settings.json`), handler types, and all event mappings.
+       * Returns null when CAAMP is unavailable at runtime.
+       *
+       * @returns Provider hook profile or null if CAAMP is unavailable
+       * @task T164
+       */
+      async getProviderProfile() {
+        try {
+          const { getProviderHookProfile } = await import("@cleocode/caamp");
+          return getProviderHookProfile(PROVIDER_ID) ?? null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Translate a CAAMP canonical event to its Claude Code native name via CAAMP.
+       *
+       * Calls `toNative(canonical, 'claude-code')` from the CAAMP normalizer.
+       * Returns null for unsupported events (PreModel, PostModel) or when
+       * CAAMP is unavailable.
+       *
+       * @param canonical - CAAMP canonical event name (e.g. "PromptSubmit")
+       * @returns Claude Code native event name or null
+       * @task T164
+       */
+      async toNativeEvent(canonical) {
+        try {
+          const { toNative } = await import("@cleocode/caamp");
+          return toNative(canonical, PROVIDER_ID);
+        } catch {
+          const entry = Object.entries(CLAUDE_CODE_EVENT_MAP).find(([, v]) => v === canonical);
+          return entry?.[0] ?? null;
+        }
+      }
+      /**
+       * Extract a plain-text transcript from Claude Code session JSONL files.
+       *
+       * Reads the most recent .jsonl file under `~/.claude/projects/` and
+       * extracts user/assistant 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; Claude Code uses global paths)
+       * @task T144 @epic T134
+       */
+      async getTranscript(_sessionId, _projectDir) {
+        try {
+          const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "/root";
+          const projectsDir = join3(homeDir, ".claude", "projects");
+          let allFiles = [];
+          try {
+            const projectDirs = await readdir(projectsDir, { withFileTypes: true });
+            for (const entry of projectDirs) {
+              if (!entry.isDirectory()) continue;
+              const subDir = join3(projectsDir, entry.name);
+              try {
+                const files = await readdir(subDir);
+                for (const file of files) {
+                  if (!file.endsWith(".jsonl")) continue;
+                  const filePath = join3(subDir, file);
+                  allFiles.push({ path: filePath, mtime: 0 });
+                }
+              } catch {
+              }
+            }
+          } catch {
+            return null;
+          }
+          if (allFiles.length === 0) return null;
+          allFiles = allFiles.sort((a, b) => b.path.localeCompare(a.path));
+          const mostRecent = allFiles[0];
+          if (!mostRecent) return null;
+          const raw = await readFile(mostRecent.path, "utf-8");
+          const lines = raw.split("\n").filter((l) => l.trim());
+          const turns = [];
+          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/claude-code/install.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+var INSTRUCTION_REFERENCES, ClaudeCodeInstallProvider;
+var init_install = __esm({
+  "packages/adapters/src/providers/claude-code/install.ts"() {
+    "use strict";
+    INSTRUCTION_REFERENCES = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+    ClaudeCodeInstallProvider = class {
+      /**
+       * Install CLEO into a Claude Code project.
+       *
+       * @param options - Installation options including project directory
+       * @returns Result describing what was installed
+       */
+      async install(options) {
+        const { projectDir } = options;
+        const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let instructionFileUpdated = false;
+        const details = {};
+        instructionFileUpdated = this.updateInstructionFile(projectDir);
+        if (instructionFileUpdated) {
+          details.instructionFile = join4(projectDir, "CLAUDE.md");
+        }
+        const pluginResult = this.registerPlugin();
+        if (pluginResult) {
+          details.plugin = pluginResult;
+        }
+        return {
+          success: true,
+          installedAt,
+          instructionFileUpdated,
+          details
+        };
+      }
+      /**
+       * Uninstall CLEO from the current Claude Code project.
+       *
+       * Does not remove CLAUDE.md references (they are harmless if CLEO is not present).
+       */
+      async uninstall() {
+      }
+      /**
+       * Check whether CLEO is installed in the current environment.
+       *
+       * Checks for plugin enabled in ~/.claude/settings.json.
+       */
+      async isInstalled() {
+        const settingsPath = join4(homedir3(), ".claude", "settings.json");
+        if (existsSync2(settingsPath)) {
+          try {
+            const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+            const plugins = settings.enabledPlugins;
+            if (plugins && plugins["cleo@cleocode"] === true) {
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      }
+      /**
+       * Ensure CLAUDE.md contains @-references to CLEO instruction files.
+       *
+       * Creates CLAUDE.md if it does not exist. Appends any missing references.
+       *
+       * @param projectDir - Project root directory
+       */
+      async ensureInstructionReferences(projectDir) {
+        this.updateInstructionFile(projectDir);
+      }
+      /**
+       * Update CLAUDE.md with CLEO @-references.
+       *
+       * @returns true if the file was created or modified
+       */
+      updateInstructionFile(projectDir) {
+        const claudeMdPath = join4(projectDir, "CLAUDE.md");
+        let content = "";
+        let existed = false;
+        if (existsSync2(claudeMdPath)) {
+          content = readFileSync2(claudeMdPath, "utf-8");
+          existed = true;
+        }
+        const missingRefs = INSTRUCTION_REFERENCES.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";
+        }
+        writeFileSync2(claudeMdPath, content, "utf-8");
+        return true;
+      }
+      /**
+       * Register the CLEO brain plugin in ~/.claude/settings.json.
+       *
+       * @returns Description of what was registered, or null if no change needed
+       */
+      registerPlugin() {
+        const home = homedir3();
+        const settingsPath = join4(home, ".claude", "settings.json");
+        let settings = {};
+        if (existsSync2(settingsPath)) {
+          try {
+            settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+          } catch {
+          }
+        }
+        const enabledPlugins = settings.enabledPlugins ?? {};
+        const pluginKey = "cleo@cleocode";
+        if (enabledPlugins[pluginKey] === true) {
+          return null;
+        }
+        if (enabledPlugins["claude-mem@thedotmack"] === true) {
+          enabledPlugins["claude-mem@thedotmack"] = false;
+        }
+        enabledPlugins[pluginKey] = true;
+        settings.enabledPlugins = enabledPlugins;
+        mkdirSync(join4(home, ".claude"), { recursive: true });
+        writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+        return `Enabled ${pluginKey} in ~/.claude/settings.json`;
+      }
+    };
+  }
+});
+
+// packages/contracts/src/errors.ts
+function getErrorMessage(error, fallback = "Unknown error") {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error !== null && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return fallback;
+}
+var init_errors = __esm({
+  "packages/contracts/src/errors.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/exit-codes.ts
+var init_exit_codes = __esm({
+  "packages/contracts/src/exit-codes.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/facade.ts
+var init_facade = __esm({
+  "packages/contracts/src/facade.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/lafs.ts
+var init_lafs = __esm({
+  "packages/contracts/src/lafs.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/issues.ts
+var init_issues = __esm({
+  "packages/contracts/src/operations/issues.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/lifecycle.ts
+var init_lifecycle = __esm({
+  "packages/contracts/src/operations/lifecycle.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/orchestrate.ts
+var init_orchestrate = __esm({
+  "packages/contracts/src/operations/orchestrate.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/release.ts
+var init_release = __esm({
+  "packages/contracts/src/operations/release.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/research.ts
+var init_research = __esm({
+  "packages/contracts/src/operations/research.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/session.ts
+var init_session = __esm({
+  "packages/contracts/src/operations/session.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/skills.ts
+var init_skills = __esm({
+  "packages/contracts/src/operations/skills.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/system.ts
+var init_system = __esm({
+  "packages/contracts/src/operations/system.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/tasks.ts
+var init_tasks = __esm({
+  "packages/contracts/src/operations/tasks.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/validate.ts
+var init_validate = __esm({
+  "packages/contracts/src/operations/validate.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/operations/index.ts
+var init_operations = __esm({
+  "packages/contracts/src/operations/index.ts"() {
+    "use strict";
+    init_issues();
+    init_lifecycle();
+    init_orchestrate();
+    init_release();
+    init_research();
+    init_session();
+    init_skills();
+    init_system();
+    init_tasks();
+    init_validate();
+  }
+});
+
+// packages/contracts/src/orchestration-hierarchy.ts
+var init_orchestration_hierarchy = __esm({
+  "packages/contracts/src/orchestration-hierarchy.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/session.ts
+var init_session2 = __esm({
+  "packages/contracts/src/session.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/status-registry.ts
+var init_status_registry = __esm({
+  "packages/contracts/src/status-registry.ts"() {
+    "use strict";
+  }
+});
+
+// packages/contracts/src/index.ts
+var init_src = __esm({
+  "packages/contracts/src/index.ts"() {
+    init_errors();
+    init_exit_codes();
+    init_facade();
+    init_lafs();
+    init_operations();
+    init_orchestration_hierarchy();
+    init_session2();
+    init_status_registry();
+  }
+});
+
+// packages/adapters/src/providers/claude-code/spawn.ts
+import { exec, spawn as nodeSpawn } from "node:child_process";
+import { unlink, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+var execAsync, ClaudeCodeSpawnProvider;
+var init_spawn = __esm({
+  "packages/adapters/src/providers/claude-code/spawn.ts"() {
+    "use strict";
+    init_src();
+    execAsync = promisify(exec);
+    ClaudeCodeSpawnProvider = class {
+      /** Map of instance IDs to tracked process info. */
+      processMap = /* @__PURE__ */ new Map();
+      /**
+       * Check if the Claude CLI is available in PATH.
+       *
+       * @returns true if `claude` is found via `which`
+       */
+      async canSpawn() {
+        try {
+          await execAsync("which claude");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Spawn a subagent via Claude CLI.
+       *
+       * Writes the prompt to a temporary file and spawns a detached Claude
+       * process. The process runs independently of the parent.
+       *
+       * @param context - Spawn context with taskId, prompt, and options
+       * @returns Spawn result with instance ID and status
+       */
+      async spawn(context) {
+        const instanceId = `claude-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = (/* @__PURE__ */ new Date()).toISOString();
+        let tmpFile;
+        try {
+          tmpFile = `/tmp/claude-spawn-${instanceId}.txt`;
+          await writeFile(tmpFile, context.prompt, "utf-8");
+          const args = ["--allow-insecure", "--no-upgrade-check", tmpFile];
+          const spawnOpts = {
+            detached: true,
+            stdio: "ignore"
+          };
+          if (context.workingDirectory) {
+            spawnOpts.cwd = context.workingDirectory;
+          }
+          const child = nodeSpawn("claude", args, spawnOpts);
+          child.unref();
+          if (child.pid) {
+            this.processMap.set(instanceId, {
+              pid: child.pid,
+              taskId: context.taskId,
+              startTime
+            });
+          }
+          const capturedTmpFile = tmpFile;
+          child.on("exit", async () => {
+            this.processMap.delete(instanceId);
+            try {
+              await unlink(capturedTmpFile);
+            } catch {
+            }
+          });
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "claude-code",
+            status: "running",
+            startTime
+          };
+        } catch (error) {
+          console.error(`[ClaudeCodeSpawnProvider] Failed to spawn: ${getErrorMessage(error)}`);
+          if (tmpFile) {
+            try {
+              await unlink(tmpFile);
+            } catch {
+            }
+          }
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "claude-code",
+            status: "failed",
+            startTime,
+            endTime: (/* @__PURE__ */ new Date()).toISOString(),
+            error: getErrorMessage(error)
+          };
+        }
+      }
+      /**
+       * List currently running Claude subagent processes.
+       *
+       * Checks each tracked process via kill(pid, 0) to verify it is still alive.
+       * Dead processes are automatically cleaned from the tracking map.
+       *
+       * @returns Array of spawn results for running processes
+       */
+      async listRunning() {
+        const running = [];
+        for (const [instanceId, tracked] of this.processMap.entries()) {
+          try {
+            process.kill(tracked.pid, 0);
+            running.push({
+              instanceId,
+              taskId: tracked.taskId,
+              providerId: "claude-code",
+              status: "running",
+              startTime: tracked.startTime
+            });
+          } catch {
+            this.processMap.delete(instanceId);
+          }
+        }
+        return running;
+      }
+      /**
+       * Terminate a running spawn by instance ID.
+       *
+       * Sends SIGTERM to the tracked process. If the process is not found
+       * or has already exited, this is a no-op.
+       *
+       * @param instanceId - ID of the spawn instance to terminate
+       */
+      async terminate(instanceId) {
+        const tracked = this.processMap.get(instanceId);
+        if (!tracked) return;
+        try {
+          process.kill(tracked.pid, "SIGTERM");
+        } catch {
+        }
+        this.processMap.delete(instanceId);
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/task-sync.ts
+import { readFile as readFile2, stat } from "node:fs/promises";
+import { join as join5 } from "node:path";
+function parseTaskId(content) {
+  const match = content.match(/^\[T(\d+)\]/);
+  return match ? `T${match[1]}` : null;
+}
+function stripPrefixes(content) {
+  return content.replace(/^\[T\d+\]\s*/, "").replace(/^\[!\]\s*/, "").replace(/^\[BLOCKED\]\s*/, "");
+}
+function mapStatus(twStatus) {
+  switch (twStatus) {
+    case "completed":
+      return "completed";
+    case "in_progress":
+      return "active";
+    case "pending":
+      return "pending";
+    default:
+      return "pending";
+  }
+}
+function getTodoWriteFilePath(projectDir) {
+  return join5(projectDir, ".cleo", "sync", "todowrite-state.json");
+}
+var ClaudeCodeTaskSyncProvider;
+var init_task_sync = __esm({
+  "packages/adapters/src/providers/claude-code/task-sync.ts"() {
+    "use strict";
+    ClaudeCodeTaskSyncProvider = class {
+      /** Optional override path for the TodoWrite state file (used in tests). */
+      customFilePath;
+      constructor(options) {
+        this.customFilePath = options?.filePath;
+      }
+      /** Retrieve external tasks from Claude's TodoWrite state file. */
+      async getExternalTasks(projectDir) {
+        const filePath = this.customFilePath ?? getTodoWriteFilePath(projectDir);
+        try {
+          await stat(filePath);
+        } catch {
+          return [];
+        }
+        const raw = await readFile2(filePath, "utf-8");
+        let state;
+        try {
+          state = JSON.parse(raw);
+        } catch {
+          return [];
+        }
+        if (!state.todos || !Array.isArray(state.todos)) {
+          return [];
+        }
+        const tasks = [];
+        let syntheticIndex = 0;
+        for (const item of state.todos) {
+          const cleoTaskId = parseTaskId(item.content);
+          const title = cleoTaskId ? stripPrefixes(item.content).trim() : item.content.trim();
+          if (!title) continue;
+          tasks.push({
+            externalId: cleoTaskId ?? `tw-new-${syntheticIndex++}`,
+            title,
+            status: mapStatus(item.status),
+            providerMeta: {
+              source: "todowrite",
+              cleoTaskId,
+              activeForm: item.activeForm,
+              rawContent: item.content
+            }
+          });
+        }
+        return tasks;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/transport.ts
+var ClaudeCodeTransportProvider;
+var init_transport = __esm({
+  "packages/adapters/src/providers/claude-code/transport.ts"() {
+    "use strict";
+    ClaudeCodeTransportProvider = class {
+      /** Provider-specific transport name used for capability negotiation. */
+      transportName = "claude-code";
+      /** Create a transport instance for inter-agent messaging. */
+      createTransport() {
+        return null;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/adapter.ts
+import { exec as exec2 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var execAsync2, ClaudeCodeAdapter;
+var init_adapter = __esm({
+  "packages/adapters/src/providers/claude-code/adapter.ts"() {
+    "use strict";
+    init_context_monitor();
+    init_hooks();
+    init_install();
+    init_paths();
+    init_spawn();
+    init_task_sync();
+    init_transport();
+    execAsync2 = promisify2(exec2);
+    ClaudeCodeAdapter = class {
+      /** Unique provider identifier. */
+      id = "claude-code";
+      /** Human-readable provider name. */
+      name = "Claude Code";
+      /** Adapter version string. */
+      version = "1.0.0";
+      /** Declared capabilities for this provider. */
+      capabilities = {
+        supportsHooks: true,
+        // 14/16 canonical events — derived from getProviderHookProfile('claude-code') in CAAMP 1.9.1.
+        // PreModel and PostModel are not supported by Claude Code.
+        supportedHookEvents: [
+          "SessionStart",
+          "SessionEnd",
+          "PromptSubmit",
+          "ResponseComplete",
+          "PreToolUse",
+          "PostToolUse",
+          "PostToolUseFailure",
+          "PermissionRequest",
+          "SubagentStart",
+          "SubagentStop",
+          "PreCompact",
+          "PostCompact",
+          "Notification",
+          "ConfigChange"
+        ],
+        supportsSpawn: true,
+        supportsInstall: true,
+        supportsInstructionFiles: true,
+        instructionFilePattern: "CLAUDE.md",
+        supportsContextMonitor: true,
+        supportsStatusline: true,
+        supportsProviderPaths: true,
+        supportsTransport: true,
+        supportsTaskSync: true
+      };
+      /** Hook provider for CAAMP event mapping and registration. */
+      hooks;
+      /** Spawn provider for launching subagent processes via `claude` CLI. */
+      spawn;
+      /** Install provider for managing instruction files and plugin registration. */
+      install;
+      /** Path provider for resolving Claude Code directory locations. */
+      paths;
+      /** Context monitor for tracking context window usage and statusline output. */
+      contextMonitor;
+      /** Transport provider for inter-agent communication. */
+      transport;
+      /** Task sync provider bridging Claude's TodoWrite format to CLEO tasks. */
+      taskSync;
+      /** Project directory this adapter was initialized with, or null. */
+      projectDir = null;
+      /** Whether {@link initialize} has been called. */
+      initialized = false;
+      constructor() {
+        this.hooks = new ClaudeCodeHookProvider();
+        this.spawn = new ClaudeCodeSpawnProvider();
+        this.install = new ClaudeCodeInstallProvider();
+        this.paths = new ClaudeCodePathProvider();
+        this.contextMonitor = new ClaudeCodeContextMonitorProvider();
+        this.transport = new ClaudeCodeTransportProvider();
+        this.taskSync = new ClaudeCodeTaskSyncProvider();
+      }
+      /**
+       * Initialize the adapter for a given project directory.
+       *
+       * Validates the environment by checking for the Claude CLI
+       * and Claude Code configuration directory.
+       *
+       * @param projectDir - Root directory of the project
+       */
+      async initialize(projectDir) {
+        this.projectDir = projectDir;
+        this.initialized = true;
+      }
+      /**
+       * Dispose the adapter and clean up resources.
+       *
+       * Unregisters hooks and releases any tracked state.
+       */
+      async dispose() {
+        if (this.hooks.isRegistered()) {
+          await this.hooks.unregisterNativeHooks();
+        }
+        this.initialized = false;
+        this.projectDir = null;
+      }
+      /**
+       * Run a health check to verify Claude Code is accessible.
+       *
+       * Checks:
+       * 1. Adapter has been initialized
+       * 2. Claude CLI is available in PATH
+       * 3. ~/.claude/ configuration directory exists
+       *
+       * @returns Health status with details about each check
+       */
+      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 execAsync2("which claude");
+          cliAvailable = stdout.trim().length > 0;
+          details.cliPath = stdout.trim();
+        } catch {
+          details.cliAvailable = false;
+        }
+        const claudeConfigDir = join6(homedir4(), ".claude");
+        const configExists = existsSync3(claudeConfigDir);
+        details.configDirExists = configExists;
+        const entrypointSet = process.env.CLAUDE_CODE_ENTRYPOINT !== void 0;
+        details.entrypointEnvSet = entrypointSet;
+        const healthy = cliAvailable;
+        details.cliAvailable = cliAvailable;
+        return {
+          healthy,
+          provider: this.id,
+          details
+        };
+      }
+      /**
+       * Check whether the adapter has been initialized.
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the project directory this adapter was initialized with.
+       */
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/claude-code/statusline.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join7 } from "node:path";
+function getClaudeSettingsPath() {
+  return process.env["CLAUDE_SETTINGS"] ?? join7(process.env["CLAUDE_HOME"] ?? join7(homedir5(), ".claude"), "settings.json");
+}
+function checkStatuslineIntegration() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!existsSync4(settingsPath)) return "no_settings";
+  try {
+    const settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+    const statusLine = settings.statusLine;
+    if (!statusLine?.type) return "not_configured";
+    if (statusLine.type !== "command") return "custom_no_cleo";
+    const cmd = statusLine.command ?? "";
+    if (cmd.includes("context-monitor.sh") || cmd.includes("cleo-statusline") || cmd.includes(".context-state.json") || cmd.includes("context-states")) {
+      return "configured";
+    }
+    const scriptPath = cmd.startsWith("~") ? cmd.replace("~", homedir5()) : cmd;
+    if (existsSync4(scriptPath)) {
+      try {
+        const content = readFileSync3(scriptPath, "utf-8");
+        if (content.includes("context-state.json")) return "configured";
+      } catch {
+      }
+    }
+    return "custom_no_cleo";
+  } catch {
+    return "no_settings";
+  }
+}
+function getStatuslineConfig(cleoHome) {
+  return {
+    statusLine: {
+      type: "command",
+      command: join7(cleoHome, "lib", "session", "context-monitor.sh")
+    }
+  };
+}
+function getSetupInstructions(cleoHome) {
+  const settingsPath = getClaudeSettingsPath();
+  return [
+    "To enable context monitoring, add to your Claude Code settings:",
+    `File: ${settingsPath}`,
+    "",
+    JSON.stringify(getStatuslineConfig(cleoHome), null, 2),
+    "",
+    "This enables real-time context window tracking in the CLI."
+  ].join("\n");
+}
+var init_statusline = __esm({
+  "packages/adapters/src/providers/claude-code/statusline.ts"() {
+    "use strict";
+  }
+});
+
+// packages/adapters/src/providers/claude-code/index.ts
+var claude_code_exports = {};
+__export(claude_code_exports, {
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  ClaudeCodeContextMonitorProvider: () => ClaudeCodeContextMonitorProvider,
+  ClaudeCodeHookProvider: () => ClaudeCodeHookProvider,
+  ClaudeCodeInstallProvider: () => ClaudeCodeInstallProvider,
+  ClaudeCodePathProvider: () => ClaudeCodePathProvider,
+  ClaudeCodeSpawnProvider: () => ClaudeCodeSpawnProvider,
+  ClaudeCodeTransportProvider: () => ClaudeCodeTransportProvider,
+  checkStatuslineIntegration: () => checkStatuslineIntegration,
+  createAdapter: () => createAdapter,
+  default: () => claude_code_default,
+  getSetupInstructions: () => getSetupInstructions,
+  getStatuslineConfig: () => getStatuslineConfig
+});
+function createAdapter() {
+  return new ClaudeCodeAdapter();
+}
+var claude_code_default;
+var init_claude_code = __esm({
+  "packages/adapters/src/providers/claude-code/index.ts"() {
+    "use strict";
+    init_adapter();
+    init_adapter();
+    init_context_monitor();
+    init_hooks();
+    init_install();
+    init_paths();
+    init_spawn();
+    init_statusline();
+    init_transport();
+    claude_code_default = ClaudeCodeAdapter;
+  }
+});
+
+// packages/adapters/src/providers/cursor/hooks.ts
+var PROVIDER_ID2, CURSOR_EVENT_MAP, CursorHookProvider;
+var init_hooks2 = __esm({
+  "packages/adapters/src/providers/cursor/hooks.ts"() {
+    "use strict";
+    PROVIDER_ID2 = "cursor";
+    CURSOR_EVENT_MAP = {
+      // CAAMP: toNative('SessionStart',       'cursor') = 'sessionStart'
+      sessionStart: "SessionStart",
+      // CAAMP: toNative('SessionEnd',         'cursor') = 'sessionEnd'
+      sessionEnd: "SessionEnd",
+      // CAAMP: toNative('PromptSubmit',       'cursor') = 'beforeSubmitPrompt'
+      beforeSubmitPrompt: "PromptSubmit",
+      // CAAMP: toNative('ResponseComplete',   'cursor') = 'stop'
+      stop: "ResponseComplete",
+      // CAAMP: toNative('PreToolUse',         'cursor') = 'preToolUse'
+      preToolUse: "PreToolUse",
+      // CAAMP: toNative('PostToolUse',        'cursor') = 'postToolUse'
+      postToolUse: "PostToolUse",
+      // CAAMP: toNative('PostToolUseFailure', 'cursor') = 'postToolUseFailure'
+      postToolUseFailure: "PostToolUseFailure",
+      // CAAMP: toNative('SubagentStart',      'cursor') = 'subagentStart'
+      subagentStart: "SubagentStart",
+      // CAAMP: toNative('SubagentStop',       'cursor') = 'subagentStop'
+      subagentStop: "SubagentStop",
+      // CAAMP: toNative('PreCompact',         'cursor') = 'preCompact'
+      preCompact: "PreCompact"
+    };
+    CursorHookProvider = class {
+      /** Whether hooks have been registered for the current session. */
+      registered = false;
+      /**
+       * Map a Cursor native event name to a CAAMP canonical hook event name.
+       *
+       * Looks up the native event name in the map derived from
+       * `getProviderHookProfile('cursor').mappings` (CAAMP 1.9.1). Cursor uses
+       * camelCase names (e.g. "preToolUse", "sessionStart").
+       *
+       * Returns null for unsupported events (PermissionRequest, PreModel,
+       * PostModel, PostCompact, Notification, ConfigChange).
+       *
+       * @param providerEvent - Cursor native event name (e.g. "preToolUse", "sessionStart")
+       * @returns CAAMP canonical event name, or null if unmapped
+       * @task T165
+       */
+      mapProviderEvent(providerEvent) {
+        return CURSOR_EVENT_MAP[providerEvent] ?? null;
+      }
+      /**
+       * Register native hooks for a project.
+       *
+       * For Cursor, hooks are registered via the config system
+       * (`.cursor/hooks.json`), managed by the install provider.
+       * This method marks hooks as registered without performing filesystem operations.
+       *
+       * Iterating supported events is handled at install time using
+       * `getSupportedCanonicalEvents()` to enumerate all 10 supported hooks.
+       *
+       * @param _projectDir - Project directory (unused; Cursor config manages registration)
+       * @task T165
+       */
+      async registerNativeHooks(_projectDir) {
+        this.registered = true;
+      }
+      /**
+       * Unregister native hooks.
+       *
+       * For Cursor, this is a no-op since hooks are managed through the config
+       * system. Unregistration happens via the install provider's uninstall method.
+       *
+       * @task T165
+       */
+      async unregisterNativeHooks() {
+        this.registered = false;
+      }
+      /**
+       * Check whether hooks have been registered via `registerNativeHooks`.
+       */
+      isRegistered() {
+        return this.registered;
+      }
+      /**
+       * Get the native→canonical event mapping for introspection and debugging.
+       *
+       * Returns the map derived from `getProviderHookProfile('cursor').mappings`
+       * (CAAMP 1.9.1). Use `getSupportedCanonicalEvents()` to enumerate canonical
+       * names via live CAAMP APIs.
+       *
+       * @returns Immutable record of native event name → canonical event name
+       */
+      getEventMap() {
+        return { ...CURSOR_EVENT_MAP };
+      }
+      /**
+       * Enumerate supported canonical events via CAAMP's `getSupportedEvents()`.
+       *
+       * Calls `getSupportedEvents('cursor')` from the CAAMP normalizer to get the
+       * authoritative list. Cursor supports 10 of 16 canonical events. Falls back
+       * to the values of the static event map when CAAMP is unavailable at runtime.
+       *
+       * @returns Array of CAAMP canonical event names supported by Cursor
+       * @task T165
+       */
+      async getSupportedCanonicalEvents() {
+        try {
+          const { getSupportedEvents } = await import("@cleocode/caamp");
+          return getSupportedEvents(PROVIDER_ID2);
+        } catch {
+          return [...new Set(Object.values(CURSOR_EVENT_MAP))];
+        }
+      }
+      /**
+       * Retrieve the full provider hook profile from CAAMP.
+       *
+       * Calls `getProviderHookProfile('cursor')` from the CAAMP normalizer to
+       * get the complete profile: hook system type (`config`), config path
+       * (`.cursor/hooks.json`), handler types (command, prompt), and all event
+       * mappings. Returns null when CAAMP is unavailable at runtime.
+       *
+       * @returns Provider hook profile or null if CAAMP is unavailable
+       * @task T165
+       */
+      async getProviderProfile() {
+        try {
+          const { getProviderHookProfile } = await import("@cleocode/caamp");
+          return getProviderHookProfile(PROVIDER_ID2) ?? null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Translate a CAAMP canonical event to its Cursor native name via CAAMP.
+       *
+       * Calls `toNative(canonical, 'cursor')` from the CAAMP normalizer.
+       * Returns null for unsupported events or when CAAMP is unavailable.
+       *
+       * @param canonical - CAAMP canonical event name (e.g. "PreToolUse")
+       * @returns Cursor native event name (e.g. "preToolUse") or null
+       * @task T165
+       */
+      async toNativeEvent(canonical) {
+        try {
+          const { toNative } = await import("@cleocode/caamp");
+          return toNative(canonical, PROVIDER_ID2);
+        } catch {
+          const entry = Object.entries(CURSOR_EVENT_MAP).find(([, v]) => v === canonical);
+          return entry?.[0] ?? null;
+        }
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/cursor/install.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join12 } from "node:path";
+var INSTRUCTION_REFERENCES3, CursorInstallProvider;
+var init_install2 = __esm({
+  "packages/adapters/src/providers/cursor/install.ts"() {
+    "use strict";
+    INSTRUCTION_REFERENCES3 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+    CursorInstallProvider = class {
+      /**
+       * Install CLEO into a Cursor project.
+       *
+       * @param options - Installation options including project directory
+       * @returns Result describing what was installed
+       */
+      async install(options) {
+        const { projectDir } = options;
+        const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let instructionFileUpdated = false;
+        const details = {};
+        instructionFileUpdated = this.updateInstructionFiles(projectDir);
+        if (instructionFileUpdated) {
+          details.instructionFiles = this.getUpdatedFileList(projectDir);
+        }
+        return {
+          success: true,
+          installedAt,
+          instructionFileUpdated,
+          details
+        };
+      }
+      /**
+       * Uninstall CLEO from the current Cursor project.
+       *
+       * Does not remove instruction file references (they are harmless if CLEO is not present).
+       */
+      async uninstall() {
+      }
+      /**
+       * Check whether CLEO is installed in the current environment.
+       *
+       * Checks for .cursor/rules/cleo.mdc or .cursorrules with CLEO references.
+       */
+      async isInstalled() {
+        const mdcPath = join12(process.cwd(), ".cursor", "rules", "cleo.mdc");
+        if (existsSync7(mdcPath)) {
+          return true;
+        }
+        const rulesPath = join12(process.cwd(), ".cursorrules");
+        if (existsSync7(rulesPath)) {
+          try {
+            const content = readFileSync5(rulesPath, "utf-8");
+            if (INSTRUCTION_REFERENCES3.some((ref) => content.includes(ref))) {
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      }
+      /**
+       * Ensure instruction files contain @-references to CLEO.
+       *
+       * Updates .cursorrules (legacy) and creates .cursor/rules/cleo.mdc (modern).
+       *
+       * @param projectDir - Project root directory
+       */
+      async ensureInstructionReferences(projectDir) {
+        this.updateInstructionFiles(projectDir);
+      }
+      /**
+       * Update instruction files with CLEO @-references.
+       *
+       * Handles both legacy (.cursorrules) and modern (.cursor/rules/cleo.mdc) formats.
+       *
+       * @returns true if any file was created or modified
+       */
+      updateInstructionFiles(projectDir) {
+        let updated = false;
+        if (this.updateLegacyRules(projectDir)) {
+          updated = true;
+        }
+        if (this.updateModernRules(projectDir)) {
+          updated = true;
+        }
+        return updated;
+      }
+      /**
+       * Update legacy .cursorrules file with @-references.
+       * Only modifies the file if it already exists (does not create it).
+       *
+       * @returns true if the file was modified
+       */
+      updateLegacyRules(projectDir) {
+        const rulesPath = join12(projectDir, ".cursorrules");
+        if (!existsSync7(rulesPath)) {
+          return false;
+        }
+        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";
+        writeFileSync4(rulesPath, content, "utf-8");
+        return true;
+      }
+      /**
+       * Create or update .cursor/rules/cleo.mdc with CLEO references.
+       *
+       * MDC (Markdown Component) format is Cursor's modern rule file format.
+       * Each .mdc file in .cursor/rules/ is loaded as a rule set.
+       *
+       * @returns true if the file was created or modified
+       */
+      updateModernRules(projectDir) {
+        const rulesDir = join12(projectDir, ".cursor", "rules");
+        const mdcPath = join12(rulesDir, "cleo.mdc");
+        const expectedContent = [
+          "---",
+          "description: CLEO task management protocol references",
+          'globs: "**/*"',
+          "alwaysApply: true",
+          "---",
+          "",
+          ...INSTRUCTION_REFERENCES3,
+          ""
+        ].join("\n");
+        if (existsSync7(mdcPath)) {
+          const existing = readFileSync5(mdcPath, "utf-8");
+          if (existing === expectedContent) {
+            return false;
+          }
+        }
+        mkdirSync2(rulesDir, { recursive: true });
+        writeFileSync4(mdcPath, expectedContent, "utf-8");
+        return true;
+      }
+      /**
+       * Get list of instruction files that were updated.
+       */
+      getUpdatedFileList(projectDir) {
+        const files = [];
+        if (existsSync7(join12(projectDir, ".cursorrules"))) {
+          files.push(join12(projectDir, ".cursorrules"));
+        }
+        files.push(join12(projectDir, ".cursor", "rules", "cleo.mdc"));
+        return files;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/cursor/adapter.ts
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join13 } from "node:path";
+var CursorAdapter;
+var init_adapter2 = __esm({
+  "packages/adapters/src/providers/cursor/adapter.ts"() {
+    "use strict";
+    init_hooks2();
+    init_install2();
+    CursorAdapter = class {
+      /** Unique provider identifier. */
+      id = "cursor";
+      /** Human-readable provider name. */
+      name = "Cursor";
+      /** Adapter version string. */
+      version = "1.0.0";
+      /** Declared capabilities for this provider. */
+      capabilities = {
+        supportsHooks: true,
+        // 10/16 canonical events — derived from getProviderHookProfile('cursor') in CAAMP 1.9.1.
+        // PermissionRequest, PreModel, PostModel, PostCompact, Notification, ConfigChange are
+        // not supported by Cursor's hook system.
+        supportedHookEvents: [
+          "SessionStart",
+          "SessionEnd",
+          "PromptSubmit",
+          "ResponseComplete",
+          "PreToolUse",
+          "PostToolUse",
+          "PostToolUseFailure",
+          "SubagentStart",
+          "SubagentStop",
+          "PreCompact"
+        ],
+        supportsSpawn: false,
+        supportsInstall: true,
+        supportsInstructionFiles: true,
+        instructionFilePattern: ".cursor/rules/*.mdc",
+        supportsContextMonitor: false,
+        supportsStatusline: false,
+        supportsProviderPaths: true,
+        supportsTransport: false,
+        supportsTaskSync: false
+      };
+      /** Hook provider for CAAMP event mapping. */
+      hooks;
+      /** Install provider for managing rule files. */
+      install;
+      /** Project directory this adapter was initialized with, or null. */
+      projectDir = null;
+      /** Whether {@link initialize} has been called. */
+      initialized = false;
+      constructor() {
+        this.hooks = new CursorHookProvider();
+        this.install = new CursorInstallProvider();
+      }
+      /**
+       * Initialize the adapter for a given project directory.
+       *
+       * @param projectDir - Root directory of the project
+       */
+      async initialize(projectDir) {
+        this.projectDir = projectDir;
+        this.initialized = true;
+      }
+      /**
+       * Dispose the adapter and clean up resources.
+       */
+      async dispose() {
+        if (this.hooks.isRegistered()) {
+          await this.hooks.unregisterNativeHooks();
+        }
+        this.initialized = false;
+        this.projectDir = null;
+      }
+      /**
+       * Run a health check to verify Cursor is accessible.
+       *
+       * Checks:
+       * 1. Adapter has been initialized
+       * 2. .cursor/ configuration directory exists in the project
+       * 3. CURSOR_EDITOR env var is set
+       *
+       * @returns Health status with details about each check
+       */
+      async healthCheck() {
+        const details = {};
+        if (!this.initialized) {
+          return {
+            healthy: false,
+            provider: this.id,
+            details: { error: "Adapter not initialized" }
+          };
+        }
+        let configExists = false;
+        if (this.projectDir) {
+          const cursorConfigDir = join13(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 = existsSync8(join13(this.projectDir, ".cursorrules"));
+          details.legacyRulesExist = legacyRulesExist;
+        }
+        const healthy = configExists || editorEnvSet;
+        details.detected = healthy;
+        return {
+          healthy,
+          provider: this.id,
+          details
+        };
+      }
+      /**
+       * Check whether the adapter has been initialized.
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the project directory this adapter was initialized with.
+       */
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/cursor/index.ts
+var cursor_exports = {};
+__export(cursor_exports, {
+  CursorAdapter: () => CursorAdapter,
+  CursorHookProvider: () => CursorHookProvider,
+  CursorInstallProvider: () => CursorInstallProvider,
+  createAdapter: () => createAdapter3,
+  default: () => cursor_default
+});
+function createAdapter3() {
+  return new CursorAdapter();
+}
+var cursor_default;
+var init_cursor = __esm({
+  "packages/adapters/src/providers/cursor/index.ts"() {
+    "use strict";
+    init_adapter2();
+    init_adapter2();
+    init_hooks2();
+    init_install2();
+    cursor_default = CursorAdapter;
+  }
+});
+
+// packages/adapters/src/providers/opencode/hooks.ts
+var PROVIDER_ID3, OPENCODE_EVENT_MAP, OpenCodeHookProvider;
+var init_hooks3 = __esm({
+  "packages/adapters/src/providers/opencode/hooks.ts"() {
+    "use strict";
+    PROVIDER_ID3 = "opencode";
+    OPENCODE_EVENT_MAP = {
+      // CAAMP: toNative('SessionStart',       'opencode') = 'event:session.created'
+      "event:session.created": "SessionStart",
+      // CAAMP: toNative('SessionEnd',         'opencode') = 'event:session.deleted'
+      "event:session.deleted": "SessionEnd",
+      // CAAMP: toNative('PromptSubmit',       'opencode') = 'chat.message'
+      "chat.message": "PromptSubmit",
+      // CAAMP: toNative('ResponseComplete',   'opencode') = 'event:session.idle'
+      "event:session.idle": "ResponseComplete",
+      // CAAMP: toNative('PreToolUse',         'opencode') = 'tool.execute.before'
+      "tool.execute.before": "PreToolUse",
+      // CAAMP: toNative('PostToolUse',        'opencode') = 'tool.execute.after'
+      "tool.execute.after": "PostToolUse",
+      // CAAMP: toNative('PermissionRequest',  'opencode') = 'permission.ask'
+      "permission.ask": "PermissionRequest",
+      // CAAMP: toNative('PreModel',           'opencode') = 'chat.params'
+      "chat.params": "PreModel",
+      // CAAMP: toNative('PreCompact',         'opencode') = 'experimental.session.compacting'
+      "experimental.session.compacting": "PreCompact",
+      // CAAMP: toNative('PostCompact',        'opencode') = 'event:session.compacted'
+      "event:session.compacted": "PostCompact"
+    };
+    OpenCodeHookProvider = class {
+      /** Whether hooks have been registered for the current session. */
+      registered = false;
+      /**
+       * Map an OpenCode native event name to a CAAMP canonical hook event name.
+       *
+       * Looks up the native event name in the map derived from
+       * `getProviderHookProfile('opencode').mappings` (CAAMP 1.9.1).
+       * Returns null for unsupported events (PostToolUseFailure, SubagentStart,
+       * SubagentStop, Notification, ConfigChange).
+       *
+       * @param providerEvent - OpenCode native event (e.g. "event:session.created", "tool.execute.before")
+       * @returns CAAMP canonical event name, or null if unmapped
+       * @task T164
+       */
+      mapProviderEvent(providerEvent) {
+        return OPENCODE_EVENT_MAP[providerEvent] ?? null;
+      }
+      /**
+       * Register native hooks for a project.
+       *
+       * For OpenCode, hooks are registered via the plugin system
+       * (`.opencode/plugins/`), managed by the install provider.
+       * This method marks hooks as registered without performing filesystem operations.
+       *
+       * Iterating supported events is handled at install time using
+       * `getSupportedCanonicalEvents()` to enumerate all 10 supported hooks.
+       *
+       * @param _projectDir - Project directory (unused; config manages registration)
+       * @task T164
+       */
+      async registerNativeHooks(_projectDir) {
+        this.registered = true;
+      }
+      /**
+       * Unregister native hooks.
+       *
+       * For OpenCode, this is a no-op since hooks are managed through the plugin
+       * system. Unregistration happens via the install provider's uninstall method.
+       *
+       * @task T164
+       */
+      async unregisterNativeHooks() {
+        this.registered = false;
+      }
+      /**
+       * Check whether hooks have been registered via `registerNativeHooks`.
+       */
+      isRegistered() {
+        return this.registered;
+      }
+      /**
+       * Get the native→canonical event mapping for introspection and debugging.
+       *
+       * Returns the map derived from `getProviderHookProfile('opencode').mappings`
+       * (CAAMP 1.9.1). Use `getSupportedCanonicalEvents()` to enumerate canonical
+       * names via live CAAMP APIs.
+       *
+       * @returns Immutable record of native event name → canonical event name
+       */
+      getEventMap() {
+        return { ...OPENCODE_EVENT_MAP };
+      }
+      /**
+       * Enumerate supported canonical events via CAAMP's `getSupportedEvents()`.
+       *
+       * Calls `getSupportedEvents('opencode')` from the CAAMP normalizer to get the
+       * authoritative list. OpenCode supports 10 of 16 canonical events via its
+       * plugin system. Falls back to the values of the static event map when
+       * CAAMP is unavailable at runtime.
+       *
+       * @returns Array of CAAMP canonical event names supported by OpenCode
+       * @task T164
+       */
+      async getSupportedCanonicalEvents() {
+        try {
+          const { getSupportedEvents } = await import("@cleocode/caamp");
+          return getSupportedEvents(PROVIDER_ID3);
+        } catch {
+          return [...new Set(Object.values(OPENCODE_EVENT_MAP))];
+        }
+      }
+      /**
+       * Retrieve the full provider hook profile from CAAMP.
+       *
+       * Calls `getProviderHookProfile('opencode')` from the CAAMP normalizer to
+       * get the complete profile: hook system type (`plugin`), config path
+       * (`.opencode/plugins/`), handler types, and all event mappings.
+       * Returns null when CAAMP is unavailable at runtime.
+       *
+       * @returns Provider hook profile or null if CAAMP is unavailable
+       * @task T164
+       */
+      async getProviderProfile() {
+        try {
+          const { getProviderHookProfile } = await import("@cleocode/caamp");
+          return getProviderHookProfile(PROVIDER_ID3) ?? null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Translate a CAAMP canonical event to its OpenCode native name via CAAMP.
+       *
+       * Calls `toNative(canonical, 'opencode')` from the CAAMP normalizer.
+       * Returns null for unsupported events or when CAAMP is unavailable.
+       *
+       * @param canonical - CAAMP canonical event name (e.g. "PreToolUse")
+       * @returns OpenCode native event name or null
+       * @task T164
+       */
+      async toNativeEvent(canonical) {
+        try {
+          const { toNative } = await import("@cleocode/caamp");
+          return toNative(canonical, PROVIDER_ID3);
+        } catch {
+          const entry = Object.entries(OPENCODE_EVENT_MAP).find(([, v]) => v === canonical);
+          return entry?.[0] ?? null;
+        }
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/install.ts
+import { existsSync as existsSync13, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join19 } from "node:path";
+var INSTRUCTION_REFERENCES6, OpenCodeInstallProvider;
+var init_install3 = __esm({
+  "packages/adapters/src/providers/opencode/install.ts"() {
+    "use strict";
+    INSTRUCTION_REFERENCES6 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+    OpenCodeInstallProvider = class {
+      /**
+       * Install CLEO into an OpenCode project.
+       *
+       * @param options - Installation options including project directory
+       * @returns Result describing what was installed
+       */
+      async install(options) {
+        const { projectDir } = options;
+        const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let instructionFileUpdated = false;
+        const details = {};
+        instructionFileUpdated = this.updateInstructionFile(projectDir);
+        if (instructionFileUpdated) {
+          details.instructionFile = join19(projectDir, "AGENTS.md");
+        }
+        return {
+          success: true,
+          installedAt,
+          instructionFileUpdated,
+          details
+        };
+      }
+      /**
+       * Uninstall CLEO from the current OpenCode project.
+       *
+       * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+       */
+      async uninstall() {
+      }
+      /**
+       * Check whether CLEO is installed in the current environment.
+       *
+       * Checks for CLEO references in AGENTS.md.
+       */
+      async isInstalled() {
+        const agentsMdPath = join19(process.cwd(), "AGENTS.md");
+        if (existsSync13(agentsMdPath)) {
+          try {
+            const content = readFileSync8(agentsMdPath, "utf-8");
+            if (INSTRUCTION_REFERENCES6.some((ref) => content.includes(ref))) {
+              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
+       */
+      async ensureInstructionReferences(projectDir) {
+        this.updateInstructionFile(projectDir);
+      }
+      /**
+       * Update AGENTS.md with CLEO @-references.
+       *
+       * @returns true if the file was created or modified
+       */
+      updateInstructionFile(projectDir) {
+        const agentsMdPath = join19(projectDir, "AGENTS.md");
+        let content = "";
+        let existed = false;
+        if (existsSync13(agentsMdPath)) {
+          content = readFileSync8(agentsMdPath, "utf-8");
+          existed = true;
+        }
+        const missingRefs = INSTRUCTION_REFERENCES6.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";
+        }
+        writeFileSync7(agentsMdPath, content, "utf-8");
+        return true;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/spawn.ts
+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 join20 } from "node:path";
+import { promisify as promisify6 } from "node:util";
+function buildOpenCodeAgentMarkdown(description, instructions) {
+  const normalizedDesc = description.replace(/\s+/g, " ").trim();
+  return [
+    "---",
+    `description: ${JSON.stringify(normalizedDesc)}`,
+    "mode: subagent",
+    "hidden: true",
+    "---",
+    "",
+    instructions.trim(),
+    ""
+  ].join("\n");
+}
+async function ensureSubagentDefinition(workingDirectory) {
+  const agentDir = join20(workingDirectory, ".opencode", "agent");
+  const agentPath = join20(agentDir, `${OPENCODE_SUBAGENT_NAME}.md`);
+  const description = "CLEO task executor with protocol compliance.";
+  const instructions = [
+    "# CLEO Subagent",
+    "",
+    "You are a CLEO subagent executing a delegated task.",
+    "Follow the CLEO protocol and complete the assigned work.",
+    "",
+    "@~/.cleo/templates/CLEO-INJECTION.md"
+  ].join("\n");
+  const content = buildOpenCodeAgentMarkdown(description, instructions);
+  await mkdir2(agentDir, { recursive: true });
+  let existing = null;
+  try {
+    existing = await readFile4(agentPath, "utf-8");
+  } catch {
+    existing = null;
+  }
+  if (existing !== content) {
+    await writeFile2(agentPath, content, "utf-8");
+  }
+  return OPENCODE_SUBAGENT_NAME;
+}
+var execAsync6, OPENCODE_SUBAGENT_NAME, OPENCODE_FALLBACK_AGENT, OpenCodeSpawnProvider;
+var init_spawn2 = __esm({
+  "packages/adapters/src/providers/opencode/spawn.ts"() {
+    "use strict";
+    execAsync6 = promisify6(exec6);
+    OPENCODE_SUBAGENT_NAME = "cleo-subagent";
+    OPENCODE_FALLBACK_AGENT = "general";
+    OpenCodeSpawnProvider = class {
+      /** Map of instance IDs to tracked process info. */
+      processMap = /* @__PURE__ */ new Map();
+      /**
+       * Check if the OpenCode CLI is available in PATH.
+       *
+       * @returns true if `opencode` is found via `which`
+       */
+      async canSpawn() {
+        try {
+          await execAsync6("which opencode");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Spawn a subagent via OpenCode CLI.
+       *
+       * Ensures the CLEO subagent definition exists in the project's
+       * .opencode/agent/ directory, then spawns a detached OpenCode
+       * process. The process runs independently of the parent.
+       *
+       * @param context - Spawn context with taskId, prompt, and options
+       * @returns Spawn result with instance ID and status
+       */
+      async spawn(context) {
+        const instanceId = `opencode-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = (/* @__PURE__ */ new Date()).toISOString();
+        const workingDirectory = context.workingDirectory ?? process.cwd();
+        try {
+          let agentName;
+          try {
+            agentName = await ensureSubagentDefinition(workingDirectory);
+          } catch {
+            agentName = OPENCODE_FALLBACK_AGENT;
+          }
+          const child = nodeSpawn2(
+            "opencode",
+            [
+              "run",
+              "--format",
+              "json",
+              "--agent",
+              agentName,
+              "--title",
+              `CLEO ${context.taskId}`,
+              context.prompt
+            ],
+            {
+              cwd: workingDirectory,
+              detached: true,
+              stdio: "ignore"
+            }
+          );
+          child.unref();
+          if (child.pid) {
+            this.processMap.set(instanceId, {
+              pid: child.pid,
+              taskId: context.taskId,
+              startTime
+            });
+          }
+          child.on("exit", () => {
+            this.processMap.delete(instanceId);
+          });
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "opencode",
+            status: "running",
+            startTime
+          };
+        } catch {
+          return {
+            instanceId,
+            taskId: context.taskId,
+            providerId: "opencode",
+            status: "failed",
+            startTime,
+            endTime: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+      /**
+       * List currently running OpenCode subagent processes.
+       *
+       * Checks each tracked process via kill(pid, 0) to verify it is still alive.
+       * Dead processes are automatically cleaned from the tracking map.
+       *
+       * @returns Array of spawn results for running processes
+       */
+      async listRunning() {
+        const running = [];
+        for (const [instanceId, tracked] of this.processMap.entries()) {
+          try {
+            process.kill(tracked.pid, 0);
+            running.push({
+              instanceId,
+              taskId: tracked.taskId,
+              providerId: "opencode",
+              status: "running",
+              startTime: tracked.startTime
+            });
+          } catch {
+            this.processMap.delete(instanceId);
+          }
+        }
+        return running;
+      }
+      /**
+       * Terminate a running spawn by instance ID.
+       *
+       * Sends SIGTERM to the tracked process. If the process is not found
+       * or has already exited, this is a no-op.
+       *
+       * @param instanceId - ID of the spawn instance to terminate
+       */
+      async terminate(instanceId) {
+        const tracked = this.processMap.get(instanceId);
+        if (!tracked) return;
+        try {
+          process.kill(tracked.pid, "SIGTERM");
+        } catch {
+        }
+        this.processMap.delete(instanceId);
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/adapter.ts
+import { exec as exec7 } from "node:child_process";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join21 } from "node:path";
+import { promisify as promisify7 } from "node:util";
+var execAsync7, OpenCodeAdapter;
+var init_adapter3 = __esm({
+  "packages/adapters/src/providers/opencode/adapter.ts"() {
+    "use strict";
+    init_hooks3();
+    init_install3();
+    init_spawn2();
+    execAsync7 = promisify7(exec7);
+    OpenCodeAdapter = class {
+      /** Unique provider identifier. */
+      id = "opencode";
+      /** Human-readable provider name. */
+      name = "OpenCode";
+      /** Adapter version string. */
+      version = "1.0.0";
+      /** Declared capabilities for this provider. */
+      capabilities = {
+        supportsHooks: true,
+        // 10/16 canonical events — derived from getProviderHookProfile('opencode') in CAAMP 1.9.1.
+        // PostToolUseFailure, SubagentStart, SubagentStop, Notification, ConfigChange are
+        // not supported by OpenCode's plugin system.
+        supportedHookEvents: [
+          "SessionStart",
+          "SessionEnd",
+          "PromptSubmit",
+          "ResponseComplete",
+          "PreToolUse",
+          "PostToolUse",
+          "PermissionRequest",
+          "PreModel",
+          "PreCompact",
+          "PostCompact"
+        ],
+        supportsSpawn: true,
+        supportsInstall: true,
+        supportsInstructionFiles: true,
+        instructionFilePattern: "AGENTS.md",
+        supportsContextMonitor: false,
+        supportsStatusline: false,
+        supportsProviderPaths: true,
+        supportsTransport: false,
+        supportsTaskSync: false
+      };
+      /** Hook provider for CAAMP event mapping via OpenCode's plugin system. */
+      hooks;
+      /** Spawn provider for launching subagent processes via `opencode run`. */
+      spawn;
+      /** Install provider for managing AGENTS.md instruction files. */
+      install;
+      /** Project directory this adapter was initialized with, or null. */
+      projectDir = null;
+      /** Whether {@link initialize} has been called. */
+      initialized = false;
+      constructor() {
+        this.hooks = new OpenCodeHookProvider();
+        this.spawn = new OpenCodeSpawnProvider();
+        this.install = new OpenCodeInstallProvider();
+      }
+      /**
+       * Initialize the adapter for a given project directory.
+       *
+       * Validates the environment by checking for the OpenCode CLI
+       * and OpenCode configuration directory.
+       *
+       * @param projectDir - Root directory of the project
+       */
+      async initialize(projectDir) {
+        this.projectDir = projectDir;
+        this.initialized = true;
+      }
+      /**
+       * Dispose the adapter and clean up resources.
+       *
+       * Unregisters hooks and releases any tracked state.
+       */
+      async dispose() {
+        if (this.hooks.isRegistered()) {
+          await this.hooks.unregisterNativeHooks();
+        }
+        this.initialized = false;
+        this.projectDir = null;
+      }
+      /**
+       * Run a health check to verify OpenCode is accessible.
+       *
+       * Checks:
+       * 1. Adapter has been initialized
+       * 2. OpenCode CLI is available in PATH
+       * 3. .opencode/ configuration directory exists in the project
+       *
+       * @returns Health status with details about each check
+       */
+      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 execAsync7("which opencode");
+          cliAvailable = stdout.trim().length > 0;
+          details.cliPath = stdout.trim();
+        } catch {
+          details.cliAvailable = false;
+        }
+        if (this.projectDir) {
+          const openCodeConfigDir = join21(this.projectDir, ".opencode");
+          const configExists = existsSync14(openCodeConfigDir);
+          details.configDirExists = configExists;
+        }
+        const versionEnvSet = process.env.OPENCODE_VERSION !== void 0;
+        details.versionEnvSet = versionEnvSet;
+        const healthy = cliAvailable;
+        details.cliAvailable = cliAvailable;
+        return {
+          healthy,
+          provider: this.id,
+          details
+        };
+      }
+      /**
+       * Check whether the adapter has been initialized.
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the project directory this adapter was initialized with.
+       */
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// packages/adapters/src/providers/opencode/index.ts
+var opencode_exports = {};
+__export(opencode_exports, {
+  OpenCodeAdapter: () => OpenCodeAdapter,
+  OpenCodeHookProvider: () => OpenCodeHookProvider,
+  OpenCodeInstallProvider: () => OpenCodeInstallProvider,
+  OpenCodeSpawnProvider: () => OpenCodeSpawnProvider,
+  createAdapter: () => createAdapter6,
+  default: () => opencode_default
+});
+function createAdapter6() {
+  return new OpenCodeAdapter();
+}
+var opencode_default;
+var init_opencode = __esm({
+  "packages/adapters/src/providers/opencode/index.ts"() {
+    "use strict";
+    init_adapter3();
+    init_adapter3();
+    init_hooks3();
+    init_install3();
+    init_spawn2();
+    opencode_default = OpenCodeAdapter;
+  }
+});
+
+// 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 join11 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+
+// packages/adapters/src/providers/codex/hooks.ts
+import { homedir as homedir6 } from "node:os";
+import { join as join9 } from "node:path";
+
+// packages/adapters/src/providers/shared/transcript-reader.ts
+import { readdir as readdir2, readFile as readFile3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+function parseTranscriptLines(raw) {
+  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 (typeof role === "string" && typeof content === "string") {
+        turns.push({ role, content });
+      }
+    } catch {
+    }
+  }
+  return turns;
+}
+async function readLatestTranscript(providerDir) {
+  let allFiles = [];
+  try {
+    const entries = await readdir2(providerDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const name = entry.name;
+      if (name.endsWith(".json") || name.endsWith(".jsonl")) {
+        allFiles.push(join8(providerDir, 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;
+  try {
+    const raw = await readFile3(mostRecent, "utf-8");
+    const turns = parseTranscriptLines(raw);
+    return turns.length > 0 ? turns.map((t) => `${t.role}: ${t.content}`).join("\n") : null;
+  } catch {
+    return null;
+  }
+}
+
+// packages/adapters/src/providers/codex/hooks.ts
+var CODEX_EVENT_MAP = {
+  SessionStart: "SessionStart",
+  PromptSubmit: "UserPromptSubmit",
+  ResponseComplete: "Stop"
+};
+var CodexHookProvider = class {
+  /** Whether hooks have been registered for the current session. */
+  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 JSON/JSONL session file under `~/.codex/`
+   * and returns its turns as 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) {
+    return readLatestTranscript(join9(homedir6(), ".codex"));
+  }
+};
+
+// packages/adapters/src/providers/codex/install.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join10 } from "node:path";
+var INSTRUCTION_REFERENCES2 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+var CodexInstallProvider = class {
+  /**
+   * Install CLEO into a Codex CLI environment.
+   *
+   * @param options - Installation options including project directory
+   * @returns Result describing what was installed
+   * @task T162
+   */
+  async install(options) {
+    const { projectDir } = options;
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let instructionFileUpdated = false;
+    const details = {};
+    instructionFileUpdated = this.updateInstructionFile(projectDir);
+    if (instructionFileUpdated) {
+      details.instructionFile = join10(projectDir, "AGENTS.md");
+    }
+    return {
+      success: true,
+      installedAt,
+      instructionFileUpdated,
+      details
+    };
+  }
+  /**
+   * Uninstall CLEO from the Codex CLI environment.
+   *
+   * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+   * @task T162
+   */
+  async uninstall() {
+  }
+  /**
+   * Check whether CLEO is installed in the Codex CLI environment.
+   *
+   * Checks for CLEO references in AGENTS.md.
+   * @task T162
+   */
+  async isInstalled() {
+    const agentsMdPath = join10(process.cwd(), "AGENTS.md");
+    if (existsSync5(agentsMdPath)) {
+      try {
+        const content = readFileSync4(agentsMdPath, "utf-8");
+        if (INSTRUCTION_REFERENCES2.some((ref) => content.includes(ref))) {
+          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);
+  }
+  /**
+   * Update AGENTS.md with CLEO @-references.
+   *
+   * @param projectDir - Project root directory
+   * @returns true if the file was created or modified
+   */
+  updateInstructionFile(projectDir) {
+    const agentsMdPath = join10(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 {
+  /** Unique provider identifier. */
+  id = "codex";
+  /** Human-readable provider name. */
+  name = "Codex";
+  /** Adapter version string. */
+  version = "1.0.0";
+  /** Declared capabilities for this provider. */
+  capabilities = {
+    supportsHooks: true,
+    supportedHookEvents: ["SessionStart", "UserPromptSubmit", "Stop"],
+    supportsSpawn: false,
+    supportsInstall: true,
+    supportsInstructionFiles: false,
+    supportsContextMonitor: false,
+    supportsStatusline: false,
+    supportsProviderPaths: false,
+    supportsTransport: false,
+    supportsTaskSync: false
+  };
+  /** Hook provider for CAAMP event mapping. */
+  hooks;
+  /** Install provider for managing instruction files. */
+  install;
+  /** Project directory this adapter was initialized with, or null. */
+  projectDir = null;
+  /** Whether {@link initialize} has been called. */
+  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 = join11(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 join16 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+
+// packages/adapters/src/providers/gemini-cli/hooks.ts
+import { homedir as homedir8 } from "node:os";
+import { join as join14 } 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 {
+  /** Whether hooks have been registered for the current session. */
+  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 JSON/JSONL session file under `~/.gemini/`
+   * and returns its turns as 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) {
+    return readLatestTranscript(join14(homedir8(), ".gemini"));
+  }
+};
+
+// packages/adapters/src/providers/gemini-cli/install.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join15 } from "node:path";
+var INSTRUCTION_REFERENCES4 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+var GeminiCliInstallProvider = class {
+  /**
+   * Install CLEO into a Gemini CLI environment.
+   *
+   * @param options - Installation options including project directory
+   * @returns Result describing what was installed
+   * @task T161
+   */
+  async install(options) {
+    const { projectDir } = options;
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let instructionFileUpdated = false;
+    const details = {};
+    instructionFileUpdated = this.updateInstructionFile(projectDir);
+    if (instructionFileUpdated) {
+      details.instructionFile = join15(projectDir, "AGENTS.md");
+    }
+    return {
+      success: true,
+      installedAt,
+      instructionFileUpdated,
+      details
+    };
+  }
+  /**
+   * Uninstall CLEO from the Gemini CLI environment.
+   *
+   * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+   * @task T161
+   */
+  async uninstall() {
+  }
+  /**
+   * Check whether CLEO is installed in the Gemini CLI environment.
+   *
+   * Checks for CLEO references in AGENTS.md.
+   * @task T161
+   */
+  async isInstalled() {
+    const agentsMdPath = join15(process.cwd(), "AGENTS.md");
+    if (existsSync9(agentsMdPath)) {
+      try {
+        const content = readFileSync6(agentsMdPath, "utf-8");
+        if (INSTRUCTION_REFERENCES4.some((ref) => content.includes(ref))) {
+          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);
+  }
+  /**
+   * 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 (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 {
+  /** Unique provider identifier. */
+  id = "gemini-cli";
+  /** Human-readable provider name. */
+  name = "Gemini CLI";
+  /** Adapter version string. */
+  version = "1.0.0";
+  /** Declared capabilities for this provider. */
+  capabilities = {
+    supportsHooks: true,
+    supportedHookEvents: [
+      "SessionStart",
+      "SessionEnd",
+      "BeforeAgent",
+      "AfterAgent",
+      "BeforeTool",
+      "AfterTool",
+      "BeforeModel",
+      "AfterModel",
+      "PreCompress",
+      "Notification"
+    ],
+    supportsSpawn: false,
+    supportsInstall: true,
+    supportsInstructionFiles: false,
+    supportsContextMonitor: false,
+    supportsStatusline: false,
+    supportsProviderPaths: false,
+    supportsTransport: false,
+    supportsTaskSync: false
+  };
+  /** Hook provider for CAAMP event mapping. */
+  hooks;
+  /** Install provider for managing instruction files. */
+  install;
+  /** Project directory this adapter was initialized with, or null. */
+  projectDir = null;
+  /** Whether {@link initialize} has been called. */
+  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 = join16(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 homedir10 } from "node:os";
+import { join as join18 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+
+// packages/adapters/src/providers/kimi/hooks.ts
+var KimiHookProvider = class {
+  /** Whether hooks have been registered (always a no-op for Kimi). */
+  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, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join17 } from "node:path";
+var INSTRUCTION_REFERENCES5 = ["@~/.cleo/templates/CLEO-INJECTION.md", "@.cleo/memory-bridge.md"];
+var KimiInstallProvider = class {
+  /**
+   * Install CLEO into a Kimi environment.
+   *
+   * @param options - Installation options including project directory
+   * @returns Result describing what was installed
+   * @task T163
+   */
+  async install(options) {
+    const { projectDir } = options;
+    const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let instructionFileUpdated = false;
+    const details = {};
+    instructionFileUpdated = this.updateInstructionFile(projectDir);
+    if (instructionFileUpdated) {
+      details.instructionFile = join17(projectDir, "AGENTS.md");
+    }
+    return {
+      success: true,
+      installedAt,
+      instructionFileUpdated,
+      details
+    };
+  }
+  /**
+   * Uninstall CLEO from the Kimi environment.
+   *
+   * Does not remove AGENTS.md references (they are harmless if CLEO is not present).
+   * @task T163
+   */
+  async uninstall() {
+  }
+  /**
+   * Check whether CLEO is installed in the Kimi environment.
+   *
+   * Checks for CLEO references in AGENTS.md.
+   * @task T163
+   */
+  async isInstalled() {
+    const agentsMdPath = join17(process.cwd(), "AGENTS.md");
+    if (existsSync11(agentsMdPath)) {
+      try {
+        const content = readFileSync7(agentsMdPath, "utf-8");
+        if (INSTRUCTION_REFERENCES5.some((ref) => content.includes(ref))) {
+          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);
+  }
+  /**
+   * Update AGENTS.md with CLEO @-references.
+   *
+   * @param projectDir - Project root directory
+   * @returns true if the file was created or modified
+   */
+  updateInstructionFile(projectDir) {
+    const agentsMdPath = join17(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 {
+  /** Unique provider identifier. */
+  id = "kimi";
+  /** Human-readable provider name. */
+  name = "Kimi";
+  /** Adapter version string. */
+  version = "1.0.0";
+  /** Declared capabilities for this provider. */
+  capabilities = {
+    supportsHooks: false,
+    supportedHookEvents: [],
+    supportsSpawn: false,
+    supportsInstall: true,
+    supportsInstructionFiles: false,
+    supportsContextMonitor: false,
+    supportsStatusline: false,
+    supportsProviderPaths: false,
+    supportsTransport: false,
+    supportsTaskSync: false
+  };
+  /** Hook provider (no-op since Kimi has no event system). */
+  hooks;
+  /** Install provider for managing instruction files. */
+  install;
+  /** Project directory this adapter was initialized with, or null. */
+  projectDir = null;
+  /** Whether {@link initialize} has been called. */
+  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 = join18(homedir10(), ".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.ts
+import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname2, join as join22, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var PROVIDER_IDS = ["claude-code", "opencode", "cursor"];
+function getProviderManifests() {
+  const manifests = [];
+  const baseDir = resolve(dirname2(fileURLToPath(import.meta.url)), "providers");
+  for (const providerId of PROVIDER_IDS) {
+    try {
+      const manifestPath = join22(baseDir, providerId, "manifest.json");
+      const raw = readFileSync9(manifestPath, "utf-8");
+      manifests.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return manifests;
+}
+async function discoverProviders() {
+  const providers = /* @__PURE__ */ new Map();
+  providers.set("claude-code", async () => {
+    const { ClaudeCodeAdapter: ClaudeCodeAdapter2 } = await Promise.resolve().then(() => (init_claude_code(), claude_code_exports));
+    return new ClaudeCodeAdapter2();
+  });
+  providers.set("opencode", async () => {
+    const { OpenCodeAdapter: OpenCodeAdapter2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
+    return new OpenCodeAdapter2();
+  });
+  providers.set("cursor", async () => {
+    const { CursorAdapter: CursorAdapter2 } = await Promise.resolve().then(() => (init_cursor(), cursor_exports));
+    return new CursorAdapter2();
+  });
+  return providers;
+}
+export {
+  ClaudeCodeAdapter,
+  ClaudeCodeContextMonitorProvider,
+  ClaudeCodeHookProvider,
+  ClaudeCodeInstallProvider,
+  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 createCodexAdapter,
+  createAdapter3 as createCursorAdapter,
+  createAdapter4 as createGeminiCliAdapter,
+  createAdapter5 as createKimiAdapter,
+  createAdapter6 as createOpenCodeAdapter,
+  discoverProviders,
+  getProviderManifests,
+  getSetupInstructions,
+  getStatuslineConfig
+};
+//# sourceMappingURL=index.js.map