@cleocode/adapters 2026.3.71 → 2026.3.73

package/dist/providers/opencode/hooks.js

@@ -1,51 +1,88 @@
 /**
  * OpenCode Hook Provider
  *
- * Maps OpenCode's native hook events to CAAMP hook events.
- * OpenCode supports 6 of 8 CAAMP events through its agent/hook system.
+ * Maps OpenCode's native hook events to CAAMP canonical hook events.
+ * OpenCode supports 10 of 16 canonical events through its plugin system.
  *
- * OpenCode event mapping:
- * - session.start     -> onSessionStart
- * - session.end       -> onSessionEnd
- * - tool.start        -> onToolStart
- * - tool.complete     -> onToolComplete
- * - error             -> onError
- * - prompt.submit     -> onPromptSubmit
+ * Event translation uses CAAMP normalizer APIs:
+ * - `toCanonical(nativeName, 'opencode')` for runtime event name resolution
+ * - `getSupportedEvents('opencode')` to enumerate supported canonical events
+ * - `getProviderHookProfile('opencode')` for the full provider profile
  *
- * @task T5240
+ * OpenCode uses a JavaScript plugin system with event-prefixed names
+ * (e.g. `event:session.created`) for some hooks and bare names for others.
+ * The map is derived from `getProviderHookProfile('opencode').mappings` in
+ * CAAMP 1.9.1. PostToolUseFailure, SubagentStart, SubagentStop, Notification,
+ * and ConfigChange are not supported by OpenCode.
+ *
+ * @task T164
+ * @epic T134
  */
+/** CAAMP provider identifier for OpenCode. */
+const PROVIDER_ID = 'opencode';
 /**
- * Mapping from OpenCode native event names to CAAMP event names.
+ * Fallback map from OpenCode native event names to CAAMP canonical names.
+ *
+ * Derived from `getProviderHookProfile('opencode').mappings` in CAAMP 1.9.1.
+ * Covers all 10 supported events. PostToolUseFailure, SubagentStart,
+ * SubagentStop, Notification, and ConfigChange are not supported by OpenCode
+ * and are absent from this map.
  *
- * OpenCode uses dot-delimited event names (e.g. "session.start")
- * while CAAMP uses camelCase (e.g. "onSessionStart").
+ * OpenCode uses dot-delimited and event-prefixed names (e.g. "event:session.created")
+ * while CAAMP canonical names are PascalCase (e.g. "SessionStart").
  */
 const OPENCODE_EVENT_MAP = {
-    'session.start': 'onSessionStart',
-    'session.end': 'onSessionEnd',
-    'tool.start': 'onToolStart',
-    'tool.complete': 'onToolComplete',
-    error: 'onError',
-    'prompt.submit': 'onPromptSubmit',
+    // 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',
 };
 /**
  * Hook provider for OpenCode.
  *
- * OpenCode registers hooks via its configuration system at
- * .opencode/config.json. Hook handlers are defined as shell commands
- * or script paths that execute when the corresponding event fires.
+ * OpenCode registers hooks via its JavaScript plugin system at
+ * `.opencode/plugins/`. Supported handler type: plugin (JavaScript).
+ *
+ * Event mapping is based on `getProviderHookProfile('opencode')` from
+ * CAAMP 1.9.1. Async accessors (`getSupportedCanonicalEvents`,
+ * `getProviderProfile`) call CAAMP directly when available.
  *
- * Since hooks are registered through the config system (managed by
- * the install provider), registerNativeHooks and unregisterNativeHooks
- * track registration state without performing filesystem operations.
+ * Since hooks are registered through the plugin system (managed by the install
+ * provider), `registerNativeHooks` and `unregisterNativeHooks` track registration
+ * state without performing filesystem operations.
+ *
+ * @task T164
+ * @epic T134
  */
 export class OpenCodeHookProvider {
     registered = false;
     /**
-     * Map an OpenCode native event name to a CAAMP hook event name.
+     * 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 event name (e.g. "session.start", "tool.complete")
-     * @returns CAAMP event name or null if unmapped
+     * @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;
@@ -53,12 +90,15 @@ export class OpenCodeHookProvider {
     /**
      * Register native hooks for a project.
      *
-     * For OpenCode, hooks are registered via the config system
-     * (.opencode/config.json), which is handled by the install provider.
-     * This method marks hooks as registered without performing
-     * filesystem operations.
+     * 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;
@@ -66,24 +106,92 @@ export class OpenCodeHookProvider {
     /**
      * Unregister native hooks.
      *
-     * For OpenCode, this is a no-op since hooks are managed through
-     * the config system. Unregistration happens via the install
-     * provider's uninstall method.
+     * 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.
+     * Check whether hooks have been registered via `registerNativeHooks`.
      */
     isRegistered() {
         return this.registered;
     }
     /**
-     * Get the full event mapping for introspection/debugging.
+     * 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_ID);
+        }
+        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_ID) ?? 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_ID);
+        }
+        catch {
+            // Invert the static map as fallback
+            const entry = Object.entries(OPENCODE_EVENT_MAP).find(([, v]) => v === canonical);
+            return entry?.[0] ?? null;
+        }
+    }
 }
 //# sourceMappingURL=hooks.js.map

package/dist/providers/opencode/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../src/providers/opencode/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH;;;;;GAKG;AACH,MAAM,kBAAkB,GAA2B;IACjD,eAAe,EAAE,gBAAgB;IACjC,aAAa,EAAE,cAAc;IAC7B,YAAY,EAAE,aAAa;IAC3B,eAAe,EAAE,gBAAgB;IACjC,KAAK,EAAE,SAAS;IAChB,eAAe,EAAE,gBAAgB;CAClC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,OAAO,oBAAoB;IACvB,UAAU,GAAG,KAAK,CAAC;IAE3B;;;;;OAKG;IACH,gBAAgB,CAAC,aAAqB;QACpC,OAAO,kBAAkB,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC;IACnD,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,mBAAmB,CAAC,WAAmB;QAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,qBAAqB;QACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,EAAE,GAAG,kBAAkB,EAAE,CAAC;IACnC,CAAC;CACF"}
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../src/providers/opencode/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,8CAA8C;AAC9C,MAAM,WAAW,GAAG,UAAmB,CAAC;AAExC;;;;;;;;;;GAUG;AACH,MAAM,kBAAkB,GAA2B;IACjD,8EAA8E;IAC9E,uBAAuB,EAAE,cAAc;IACvC,8EAA8E;IAC9E,uBAAuB,EAAE,YAAY;IACrC,qEAAqE;IACrE,cAAc,EAAE,cAAc;IAC9B,2EAA2E;IAC3E,oBAAoB,EAAE,kBAAkB;IACxC,4EAA4E;IAC5E,qBAAqB,EAAE,YAAY;IACnC,2EAA2E;IAC3E,oBAAoB,EAAE,aAAa;IACnC,uEAAuE;IACvE,gBAAgB,EAAE,mBAAmB;IACrC,oEAAoE;IACpE,aAAa,EAAE,UAAU;IACzB,wFAAwF;IACxF,iCAAiC,EAAE,YAAY;IAC/C,gFAAgF;IAChF,yBAAyB,EAAE,aAAa;CACzC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,oBAAoB;IACvB,UAAU,GAAG,KAAK,CAAC;IAE3B;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,aAAqB;QACpC,OAAO,kBAAkB,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC;IACnD,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,mBAAmB,CAAC,WAAmB;QAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,qBAAqB;QACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW;QACT,OAAO,EAAE,GAAG,kBAAkB,EAAE,CAAC;IACnC,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,2BAA2B;QAC/B,IAAI,CAAC;YACH,MAAM,EAAE,kBAAkB,EAAE,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;YAC/D,OAAO,kBAAkB,CAAC,WAAW,CAAa,CAAC;QACrD,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,kBAAkB;QACtB,IAAI,CAAC;YACH,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;YACnE,OAAO,sBAAsB,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC;QACrD,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,aAAa,CAAC,SAAiB;QACnC,IAAI,CAAC;YACH,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;YACrD,OAAO,QAAQ,CAAC,SAA2C,EAAE,WAAW,CAAC,CAAC;QAC5E,CAAC;QAAC,MAAM,CAAC;YACP,oCAAoC;YACpC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;YAClF,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/adapters",
-  "version": "2026.3.71",
+  "version": "2026.3.73",
   "description": "Unified provider adapters for CLEO (Claude Code, OpenCode, Cursor)",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,8 @@
     }
   },
   "dependencies": {
-    "@cleocode/contracts": "2026.3.71"
+    "@cleocode/caamp": "^1.9.1",
+    "@cleocode/contracts": "2026.3.73"
   },
   "license": "MIT",
   "engines": {

package/src/index.ts

@@ -20,12 +20,30 @@ export {
   getSetupInstructions,
   getStatuslineConfig,
 } from './providers/claude-code/index.js';
+export {
+  CodexAdapter,
+  CodexHookProvider,
+  CodexInstallProvider,
+  createAdapter as createCodexAdapter,
+} from './providers/codex/index.js';
 export {
   CursorAdapter,
   CursorHookProvider,
   CursorInstallProvider,
   createAdapter as createCursorAdapter,
 } from './providers/cursor/index.js';
+export {
+  createAdapter as createGeminiCliAdapter,
+  GeminiCliAdapter,
+  GeminiCliHookProvider,
+  GeminiCliInstallProvider,
+} from './providers/gemini-cli/index.js';
+export {
+  createAdapter as createKimiAdapter,
+  KimiAdapter,
+  KimiHookProvider,
+  KimiInstallProvider,
+} from './providers/kimi/index.js';
 export {
   createAdapter as createOpenCodeAdapter,
   OpenCodeAdapter,

package/src/providers/claude-code/adapter.ts

@@ -42,12 +42,23 @@ export class ClaudeCodeAdapter implements CLEOProviderAdapter {
 
   capabilities: AdapterCapabilities = {
     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: [
-      'onSessionStart',
-      'onSessionEnd',
-      'onToolStart',
-      'onToolComplete',
-      'onError',
+      'SessionStart',
+      'SessionEnd',
+      'PromptSubmit',
+      'ResponseComplete',
+      'PreToolUse',
+      'PostToolUse',
+      'PostToolUseFailure',
+      'PermissionRequest',
+      'SubagentStart',
+      'SubagentStop',
+      'PreCompact',
+      'PostCompact',
+      'Notification',
+      'ConfigChange',
     ],
     supportsSpawn: true,
     supportsInstall: true,

package/src/providers/claude-code/hooks.ts

@@ -1,12 +1,18 @@
 /**
  * Claude Code Hook Provider
  *
- * Maps Claude Code's native hook events to CAAMP hook events.
- * Claude Code uses: SessionStart, PostToolUse, UserPromptSubmit, Stop
- * CAAMP defines: onSessionStart, onToolComplete, onPromptSubmit, onSessionEnd
+ * Maps Claude Code's native hook events to CAAMP canonical hook events.
+ * Claude Code supports 14 of 16 canonical events (all except PreModel, PostModel).
  *
- * @task T5240
- * @task T144
+ * Event translation uses CAAMP normalizer APIs:
+ * - `toCanonical(nativeName, 'claude-code')` for runtime event name resolution
+ * - `getSupportedEvents('claude-code')` to enumerate supported canonical events
+ * - `getProviderHookProfile('claude-code')` for the full provider profile
+ *
+ * A static map derived from CAAMP 1.9.1 hook-mappings.json is maintained as
+ * a fallback for environments where CAAMP's runtime resolution is unavailable.
+ *
+ * @task T164
  * @epic T134
  */
 
@@ -14,35 +20,81 @@ import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { AdapterHookProvider } from '@cleocode/contracts';
 
+/** CAAMP provider identifier for Claude Code. */
+const PROVIDER_ID = 'claude-code' as const;
+
 /**
- * Mapping from Claude Code native event names to CAAMP event names.
+ * Fallback map from Claude Code native event names to CAAMP canonical names.
+ *
+ * Derived from `getProviderHookProfile('claude-code').mappings` in CAAMP 1.9.1.
+ * Covers all 14 supported events. PreModel and PostModel are not supported
+ * by Claude Code and are absent from this map.
+ *
+ * Used as fallback when CAAMP runtime is unavailable, and as the synchronous
+ * implementation of `mapProviderEvent()`.
  */
 const CLAUDE_CODE_EVENT_MAP: Record<string, string> = {
-  SessionStart: 'onSessionStart',
-  PostToolUse: 'onToolComplete',
-  UserPromptSubmit: 'onPromptSubmit',
-  Stop: 'onSessionEnd',
+  // 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',
 };
 
 /**
  * Hook provider for Claude Code.
  *
- * Claude Code registers hooks via a plugin directory
- * with a hooks.json descriptor. The actual hook scripts are shell scripts
- * that invoke CLEO's brain observation system.
+ * Claude Code registers hooks via its global config at `~/.claude/settings.json`.
+ * Supported handler types: command, http, prompt, agent.
+ *
+ * Event mapping is based on `getProviderHookProfile('claude-code')` from
+ * CAAMP 1.9.1. Async accessors (`getSupportedCanonicalEvents`,
+ * `getProviderProfile`) call CAAMP directly when available.
  *
- * Since hooks are registered through the plugin system (installed via
- * the install provider), registerNativeHooks and unregisterNativeHooks
- * are effectively no-ops here — the plugin installer handles registration.
+ * Since hooks are registered through the config system (managed by the install
+ * provider), `registerNativeHooks` and `unregisterNativeHooks` track registration
+ * state without performing filesystem operations.
+ *
+ * @task T164
+ * @epic T134
  */
 export class ClaudeCodeHookProvider implements AdapterHookProvider {
   private registered = false;
 
   /**
-   * Map a Claude Code native event name to a CAAMP hook event name.
+   * 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 event name (e.g. "SessionStart", "PostToolUse")
-   * @returns CAAMP event name or null if unmapped
+   * @param providerEvent - Claude Code native event (e.g. "UserPromptSubmit", "Stop")
+   * @returns CAAMP canonical event name, or null if unmapped
+   * @task T164
    */
   mapProviderEvent(providerEvent: string): string | null {
     return CLAUDE_CODE_EVENT_MAP[providerEvent] ?? null;
@@ -51,12 +103,15 @@ export class ClaudeCodeHookProvider implements AdapterHookProvider {
   /**
    * Register native hooks for a project.
    *
-   * For Claude Code, hooks are registered via the plugin system
-   * (hooks.json descriptor), which is handled by the
-   * install provider. This method is a no-op since registration
-   * is managed through the plugin install lifecycle.
+   * 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.
    *
-   * @param _projectDir - Project directory (unused; hooks are global)
+   * 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: string): Promise<void> {
     this.registered = true;
@@ -65,32 +120,101 @@ export class ClaudeCodeHookProvider implements AdapterHookProvider {
   /**
    * Unregister native hooks.
    *
-   * For Claude Code, this is a no-op since hooks are managed through
-   * the plugin system. Unregistration happens via the install provider's
-   * uninstall method.
+   * 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(): Promise<void> {
     this.registered = false;
   }
 
   /**
-   * Check whether hooks have been registered via registerNativeHooks.
+   * Check whether hooks have been registered via `registerNativeHooks`.
    */
   isRegistered(): boolean {
     return this.registered;
   }
 
   /**
-   * Get the full event mapping for introspection/debugging.
+   * 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(): Readonly<Record<string, string>> {
     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(): Promise<string[]> {
+    try {
+      const { getSupportedEvents } = await import('@cleocode/caamp');
+      return getSupportedEvents(PROVIDER_ID) as string[];
+    } 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(): Promise<unknown | null> {
+    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: string): Promise<string | null> {
+    try {
+      const { toNative } = await import('@cleocode/caamp');
+      return toNative(canonical as Parameters<typeof toNative>[0], PROVIDER_ID);
+    } catch {
+      // Invert the static map as fallback
+      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
+   * Reads the most recent .jsonl file under `~/.claude/projects/` and
    * extracts user/assistant turn text into a flat string for brain
    * observation extraction.
    *