@cleocode/adapters 2026.4.12 → 2026.4.14

package/dist/providers/claude-code/adapter.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Claude Code Adapter
+ *
+ * Main CLEOProviderAdapter implementation for Anthropic's Claude Code CLI.
+ * Provides spawn, hooks, and install capabilities for CLEO integration.
+ *
+ * @task T5240
+ */
+import type { AdapterCapabilities, AdapterHealthStatus, CLEOProviderAdapter } from '@cleocode/contracts';
+import { ClaudeCodeContextMonitorProvider } from './context-monitor.js';
+import { ClaudeCodeHookProvider } from './hooks.js';
+import { ClaudeCodeInstallProvider } from './install.js';
+import { ClaudeCodePathProvider } from './paths.js';
+import { ClaudeCodeSpawnProvider } from './spawn.js';
+import { ClaudeCodeTaskSyncProvider } from './task-sync.js';
+import { ClaudeCodeTransportProvider } from './transport.js';
+/**
+ * CLEO provider adapter for Anthropic Claude Code CLI.
+ *
+ * Bridges CLEO's adapter system with Claude Code's native capabilities:
+ * - Hooks: Maps Claude Code events (SessionStart, PostToolUse, etc.) to CAAMP events
+ * - Spawn: Launches subagent processes via the `claude` CLI
+ * - Install: Manages instruction files and brain observation plugin registration
+ *
+ * @remarks
+ * This is the most feature-complete adapter in the CLEO system, supporting
+ * 14 of 16 CAAMP canonical events, subagent spawning via the `claude` CLI,
+ * context monitoring with statusline integration, task sync via TodoWrite,
+ * and inter-agent transport. It serves as the reference implementation for
+ * other provider adapters.
+ */
+export declare class ClaudeCodeAdapter implements CLEOProviderAdapter {
+    /** Unique provider identifier. */
+    readonly id = "claude-code";
+    /** Human-readable provider name. */
+    readonly name = "Claude Code";
+    /** Adapter version string. */
+    readonly version = "1.0.0";
+    /** Declared capabilities for this provider. */
+    capabilities: AdapterCapabilities;
+    /** Hook provider for CAAMP event mapping and registration. */
+    hooks: ClaudeCodeHookProvider;
+    /** Spawn provider for launching subagent processes via `claude` CLI. */
+    spawn: ClaudeCodeSpawnProvider;
+    /** Install provider for managing instruction files and plugin registration. */
+    install: ClaudeCodeInstallProvider;
+    /** Path provider for resolving Claude Code directory locations. */
+    paths: ClaudeCodePathProvider;
+    /** Context monitor for tracking context window usage and statusline output. */
+    contextMonitor: ClaudeCodeContextMonitorProvider;
+    /** Transport provider for inter-agent communication. */
+    transport: ClaudeCodeTransportProvider;
+    /** Task sync provider bridging Claude's TodoWrite format to CLEO tasks. */
+    taskSync: ClaudeCodeTaskSyncProvider;
+    /** Project directory this adapter was initialized with, or null. */
+    private projectDir;
+    /** Whether {@link initialize} has been called. */
+    private initialized;
+    constructor();
+    /**
+     * 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
+     */
+    initialize(projectDir: string): Promise<void>;
+    /**
+     * Dispose the adapter and clean up resources.
+     *
+     * Unregisters hooks and releases any tracked state.
+     */
+    dispose(): Promise<void>;
+    /**
+     * 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
+     */
+    healthCheck(): Promise<AdapterHealthStatus>;
+    /**
+     * Check whether the adapter has been initialized.
+     */
+    isInitialized(): boolean;
+    /**
+     * Get the project directory this adapter was initialized with.
+     */
+    getProjectDir(): string | null;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/providers/claude-code/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAI7D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAC3D,kCAAkC;IAClC,QAAQ,CAAC,EAAE,iBAAiB;IAC5B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,WAAW;IAE3B,+CAA+C;IAC/C,YAAY,EAAE,mBAAmB,CA6B/B;IAEF,8DAA8D;IAC9D,KAAK,EAAE,sBAAsB,CAAC;IAC9B,wEAAwE;IACxE,KAAK,EAAE,uBAAuB,CAAC;IAC/B,+EAA+E;IAC/E,OAAO,EAAE,yBAAyB,CAAC;IACnC,mEAAmE;IACnE,KAAK,EAAE,sBAAsB,CAAC;IAC9B,+EAA+E;IAC/E,cAAc,EAAE,gCAAgC,CAAC;IACjD,wDAAwD;IACxD,SAAS,EAAE,2BAA2B,CAAC;IACvC,2EAA2E;IAC3E,QAAQ,EAAE,0BAA0B,CAAC;IAErC,oEAAoE;IACpE,OAAO,CAAC,UAAU,CAAuB;IACzC,kDAAkD;IAClD,OAAO,CAAC,WAAW,CAAS;;IAY5B;;;;;;;OAOG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;;;;;;;OASG;IACG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAyCjD;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,GAAG,IAAI;CAG/B"}

package/dist/providers/claude-code/context-monitor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Claude Code context monitor provider.
+ *
+ * Implements AdapterContextMonitorProvider for Claude Code's context window
+ * tracking and statusline integration.
+ *
+ * @task T5240
+ */
+import type { AdapterContextMonitorProvider } from '@cleocode/contracts';
+/**
+ * Context monitor provider for Claude Code.
+ *
+ * Processes context window JSON from Claude Code and writes state files
+ * for statusline display. Also provides statusline configuration
+ * and setup instructions specific to Claude Code's settings.json.
+ *
+ * @remarks
+ * The provider writes a JSON state file to `.cleo/context-states/.context-state.json`
+ * which can be read by external statusline scripts (e.g. tmux, starship).
+ * Context thresholds at 50%, 70%, 85%, and 95% map to warning, caution,
+ * critical, and emergency status levels respectively.
+ */
+export declare class ClaudeCodeContextMonitorProvider implements AdapterContextMonitorProvider {
+    /** Path provider for resolving Claude Code directory locations. */
+    private pathProvider;
+    /** Process raw context window JSON and return a formatted summary string. */
+    processContextInput(input: unknown, cwd?: string): Promise<string>;
+    /** Check the current statusline integration status in Claude Code settings. */
+    checkStatuslineIntegration(): 'configured' | 'not_configured' | 'custom_no_cleo' | 'no_settings';
+    /** Get the recommended statusline configuration object for Claude Code settings. */
+    getStatuslineConfig(): Record<string, unknown>;
+    /** Get human-readable setup instructions for enabling context monitoring. */
+    getSetupInstructions(): string;
+}
+//# sourceMappingURL=context-monitor.d.ts.map

package/dist/providers/claude-code/context-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-monitor.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/context-monitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAkCzE;;;;;;;;;;;;GAYG;AACH,qBAAa,gCAAiC,YAAW,6BAA6B;IACpF,mEAAmE;IACnE,OAAO,CAAC,YAAY,CAAgC;IAEpD,6EAA6E;IACvE,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA0DxE,+EAA+E;IAC/E,0BAA0B,IAAI,YAAY,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,aAAa;IAsChG,oFAAoF;IACpF,mBAAmB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAS9C,6EAA6E;IAC7E,oBAAoB,IAAI,MAAM;CAY/B"}

package/dist/providers/claude-code/hooks.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Claude Code Hook Provider
+ *
+ * Maps Claude Code's native hook events to CAAMP canonical hook events.
+ * Claude Code supports 14 of 16 canonical events (all except PreModel, PostModel).
+ *
+ * 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
+ */
+import type { AdapterHookProvider } from '@cleocode/contracts';
+/**
+ * Hook provider for Claude Code.
+ *
+ * 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 config system (managed by the install
+ * provider), `registerNativeHooks` and `unregisterNativeHooks` track registration
+ * state without performing filesystem operations.
+ *
+ * @remarks
+ * Claude Code is the only provider that supports all 14 of its declared
+ * canonical events at runtime. The static event map is maintained as a
+ * synchronous fallback; async methods like {@link getSupportedCanonicalEvents}
+ * and {@link getProviderProfile} call CAAMP directly when available.
+ *
+ * @task T164
+ * @epic T134
+ */
+export declare class ClaudeCodeHookProvider implements AdapterHookProvider {
+    /** Whether hooks have been registered for the current session. */
+    private registered;
+    /**
+     * 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: string): string | 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
+     */
+    registerNativeHooks(_projectDir: string): Promise<void>;
+    /**
+     * 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
+     */
+    unregisterNativeHooks(): Promise<void>;
+    /**
+     * Check whether hooks have been registered via `registerNativeHooks`.
+     */
+    isRegistered(): boolean;
+    /**
+     * 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>>;
+    /**
+     * 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
+     */
+    getSupportedCanonicalEvents(): Promise<string[]>;
+    /**
+     * 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
+     */
+    getProviderProfile(): Promise<unknown | 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
+     */
+    toNativeEvent(canonical: string): Promise<string | 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
+     */
+    getTranscript(_sessionId: string, _projectDir: string): Promise<string | null>;
+}
+//# sourceMappingURL=hooks.d.ts.map

package/dist/providers/claude-code/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AA8C/D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,sBAAuB,YAAW,mBAAmB;IAChE,kEAAkE;IAClE,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAItD;;;;;;;;;;;;OAYG;IACG,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7D;;;;;;;OAOG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5C;;OAEG;IACH,YAAY,IAAI,OAAO;IAIvB;;;;;;;;OAQG;IACH,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAI/C;;;;;;;;;;OAUG;IACG,2BAA2B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAStD;;;;;;;;;;OAUG;IACG,kBAAkB,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IASnD;;;;;;;;;;OAUG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAW9D;;;;;;;;;;;;OAYG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CA2DrF"}

package/dist/providers/claude-code/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ *
+ * CLEO provider adapter for Anthropic Claude Code CLI.
+ * Default export is the adapter class for dynamic loading by AdapterManager.
+ *
+ * @task T5240
+ */
+import { ClaudeCodeAdapter } from './adapter.js';
+export { ClaudeCodeAdapter } from './adapter.js';
+export { ClaudeCodeContextMonitorProvider } from './context-monitor.js';
+export { ClaudeCodeHookProvider } from './hooks.js';
+export { ClaudeCodeInstallProvider } from './install.js';
+export { ClaudeCodePathProvider } from './paths.js';
+export { ClaudeCodeSpawnProvider } from './spawn.js';
+export { checkStatuslineIntegration, getSetupInstructions, getStatuslineConfig, } from './statusline.js';
+export { ClaudeCodeTransportProvider } from './transport.js';
+export default ClaudeCodeAdapter;
+/**
+ * Factory function for creating adapter instances.
+ * Used by AdapterManager's dynamic import fallback.
+ *
+ * @remarks
+ * This is the primary entry point for dynamic adapter loading.
+ * AdapterManager calls this function when it resolves the claude-code
+ * provider via its import-based discovery mechanism.
+ *
+ * @returns A new {@link ClaudeCodeAdapter} instance ready for initialization
+ *
+ * @example
+ * ```typescript
+ * import { createAdapter } from '@cleocode/adapters/providers/claude-code';
+ *
+ * const adapter = createAdapter();
+ * await adapter.initialize('/path/to/project');
+ * ```
+ */
+export declare function createAdapter(): ClaudeCodeAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/claude-code/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAE7D,eAAe,iBAAiB,CAAC;AAEjC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,IAAI,iBAAiB,CAEjD"}

package/dist/providers/claude-code/install.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Claude Code Install Provider
+ *
+ * Handles CLEO installation into Claude Code environments:
+ * - Ensures CLAUDE.md has CLEO @-references
+ * - Manages plugin registration in ~/.claude/settings.json
+ *
+ * Migrated from src/core/install/claude-plugin.ts
+ *
+ * @task T5240
+ */
+import type { AdapterInstallProvider, InstallOptions, InstallResult } from '@cleocode/contracts';
+/**
+ * Install provider for Claude Code.
+ *
+ * Manages CLEO's integration with Claude Code by:
+ * 1. Ensuring CLAUDE.md contains @-references to CLEO instruction files
+ * 2. Registering the brain observation plugin in ~/.claude/settings.json
+ *
+ * @remarks
+ * Installation is idempotent -- running install multiple times on the same
+ * project produces the same result. The provider disables the legacy
+ * `claude-mem\@thedotmack` plugin if present and enables the unified
+ * `cleo\@cleocode` plugin instead.
+ */
+export declare class ClaudeCodeInstallProvider implements AdapterInstallProvider {
+    /**
+     * Install CLEO into a Claude Code project.
+     *
+     * @param options - Installation options including project directory
+     * @returns Result describing what was installed
+     */
+    install(options: InstallOptions): Promise<InstallResult>;
+    /**
+     * Uninstall CLEO from the current Claude Code project.
+     *
+     * Does not remove CLAUDE.md references (they are harmless if CLEO is not present).
+     */
+    uninstall(): Promise<void>;
+    /**
+     * Check whether CLEO is installed in the current environment.
+     *
+     * Checks for plugin enabled in ~/.claude/settings.json.
+     */
+    isInstalled(): Promise<boolean>;
+    /**
+     * 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
+     */
+    ensureInstructionReferences(projectDir: string): Promise<void>;
+    /**
+     * Update CLAUDE.md with CLEO @-references.
+     *
+     * @returns true if the file was created or modified
+     */
+    private updateInstructionFile;
+    /**
+     * Register the CLEO brain plugin in ~/.claude/settings.json.
+     *
+     * @returns Description of what was registered, or null if no change needed
+     */
+    private registerPlugin;
+}
+//# sourceMappingURL=install.d.ts.map

package/dist/providers/claude-code/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/install.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKjG;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAA0B,YAAW,sBAAsB;IACtE;;;;;OAKG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;IA0B9D;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAEhC;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAkBrC;;;;;;OAMG;IACG,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpE;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA+B7B;;;;OAIG;IACH,OAAO,CAAC,cAAc;CAiCvB"}

package/dist/providers/claude-code/paths.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Claude Code path provider.
+ *
+ * Implements AdapterPathProvider with Claude Code-specific directory locations.
+ *
+ * @task T5240
+ */
+import type { AdapterPathProvider } from '@cleocode/contracts';
+/**
+ * Path provider for Anthropic Claude Code CLI.
+ *
+ * Resolves Claude Code's standard directory layout:
+ * - Config dir: ~/.claude (or CLAUDE_HOME)
+ * - Settings: ~/.claude/settings.json (or CLAUDE_SETTINGS)
+ * - Agents: ~/.claude/agents
+ * - Memory DB: ~/.claude-mem/claude-mem.db (or CLAUDE_MEM_DB)
+ *
+ * @remarks
+ * All paths respect environment variable overrides for CI and non-standard
+ * installations. When env vars are unset, the canonical default paths are used.
+ */
+export declare class ClaudeCodePathProvider implements AdapterPathProvider {
+    /** Get the provider's root configuration directory. */
+    getProviderDir(): string;
+    /** Get the path to the provider's settings file, or null if unavailable. */
+    getSettingsPath(): string | null;
+    /** Get the directory where agents are installed, or null if unsupported. */
+    getAgentInstallDir(): string | null;
+    /** Get the path to the provider's memory database, or null if unsupported. */
+    getMemoryDbPath(): string | null;
+}
+//# sourceMappingURL=paths.d.ts.map

package/dist/providers/claude-code/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/paths.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAuB,YAAW,mBAAmB;IAChE,uDAAuD;IACvD,cAAc,IAAI,MAAM;IAIxB,4EAA4E;IAC5E,eAAe,IAAI,MAAM,GAAG,IAAI;IAIhC,4EAA4E;IAC5E,kBAAkB,IAAI,MAAM,GAAG,IAAI;IAInC,8EAA8E;IAC9E,eAAe,IAAI,MAAM,GAAG,IAAI;CAGjC"}

package/dist/providers/claude-code/spawn.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Claude Code Spawn Provider
+ *
+ * Implements AdapterSpawnProvider for Claude Code CLI.
+ * Migrated from src/core/spawn/adapters/claude-code-adapter.ts
+ *
+ * Uses the native `claude` CLI to spawn subagent processes with prompts
+ * written to temporary files. Processes run detached and are tracked
+ * by PID for listing and termination.
+ *
+ * @task T5240
+ */
+import type { AdapterSpawnProvider, SpawnContext, SpawnResult } from '@cleocode/contracts';
+/**
+ * Spawn provider for Claude Code.
+ *
+ * Spawns detached Claude CLI processes for subagent execution.
+ * Each spawn writes its prompt to a temporary file, then runs
+ * `claude --allow-insecure --no-upgrade-check <tmpFile>` as a
+ * detached, unref'd child process.
+ *
+ * @remarks
+ * The provider uses `--allow-insecure --no-upgrade-check` flags to
+ * ensure the Claude CLI starts without interactive prompts. Prompts are
+ * written to temporary files under `/tmp/` and cleaned up after the
+ * child process exits. Processes are tracked by instance ID in an
+ * in-memory map and verified via `kill(pid, 0)` liveness checks.
+ */
+export declare class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
+    /** Map of instance IDs to tracked process info. */
+    private processMap;
+    /**
+     * Check if the Claude CLI is available in PATH.
+     *
+     * @returns true if `claude` is found via `which`
+     */
+    canSpawn(): Promise<boolean>;
+    /**
+     * 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
+     */
+    spawn(context: SpawnContext): Promise<SpawnResult>;
+    /**
+     * 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
+     */
+    listRunning(): Promise<SpawnResult[]>;
+    /**
+     * 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
+     */
+    terminate(instanceId: string): Promise<void>;
+}
+//# sourceMappingURL=spawn.d.ts.map

package/dist/providers/claude-code/spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/spawn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAY3F;;;;;;;;;;;;;;GAcG;AACH,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,mDAAmD;IACnD,OAAO,CAAC,UAAU,CAAqC;IAEvD;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IASlC;;;;;;;;OAQG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAuExD;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAqB3C;;;;;;;OAOG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnD"}

package/dist/providers/claude-code/statusline.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Statusline integration for the Claude Code adapter.
+ *
+ * Implements the statusline portion of AdapterContextMonitorProvider.
+ * Checks and configures Claude Code status line for context monitoring.
+ *
+ * @task T5240
+ */
+type StatuslineStatus = 'configured' | 'not_configured' | 'custom_no_cleo' | 'no_settings';
+/**
+ * Check if statusline integration is configured.
+ * Returns the current integration status.
+ *
+ * @remarks
+ * Reads Claude Code's settings.json and inspects the `statusLine` field
+ * to determine whether CLEO context monitoring is active.
+ *
+ * @returns One of: 'configured', 'not_configured', 'custom_no_cleo', 'no_settings'
+ *
+ * @example
+ * ```typescript
+ * import { checkStatuslineIntegration } from './statusline.js';
+ *
+ * const status = checkStatuslineIntegration();
+ * if (status === 'not_configured') {
+ *   console.log('Run cleo install to set up context monitoring');
+ * }
+ * ```
+ */
+export declare function checkStatuslineIntegration(): StatuslineStatus;
+/**
+ * Get the statusline setup command for Claude Code settings.
+ *
+ * @remarks
+ * Returns a JSON-serializable object that can be merged into
+ * Claude Code's settings.json to enable context monitoring.
+ *
+ * @param cleoHome - Absolute path to the CLEO home directory
+ * @returns Settings object containing the statusLine configuration
+ *
+ * @example
+ * ```typescript
+ * import { getStatuslineConfig } from './statusline.js';
+ *
+ * const config = getStatuslineConfig('/home/user/.cleo');
+ * ```
+ */
+export declare function getStatuslineConfig(cleoHome: string): Record<string, unknown>;
+/**
+ * Get human-readable setup instructions.
+ *
+ * @remarks
+ * Returns a multi-line string with file path, JSON config, and explanation
+ * suitable for display to the user.
+ *
+ * @param cleoHome - Absolute path to the CLEO home directory
+ * @returns Formatted setup instructions string
+ *
+ * @example
+ * ```typescript
+ * import { getSetupInstructions } from './statusline.js';
+ *
+ * console.log(getSetupInstructions('/home/user/.cleo'));
+ * ```
+ */
+export declare function getSetupInstructions(cleoHome: string): string;
+export {};
+//# sourceMappingURL=statusline.d.ts.map

package/dist/providers/claude-code/statusline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statusline.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/statusline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,KAAK,gBAAgB,GAAG,YAAY,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAa3F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,0BAA0B,IAAI,gBAAgB,CAwC7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO7E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAW7D"}

package/dist/providers/claude-code/task-sync.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Claude Code TaskSyncProvider — bridges Claude's TodoWrite format
+ * to the provider-agnostic reconciliation system.
+ *
+ * All Claude Code / TodoWrite-specific parsing lives here.
+ * The core reconciliation engine never sees TodoWrite formats.
+ */
+import type { ExternalTask, ExternalTaskProvider } from '@cleocode/contracts';
+/**
+ * Claude Code TaskSyncProvider.
+ *
+ * Reads Claude's TodoWrite JSON state, parses [T001]-prefixed task IDs
+ * and status, and returns normalized ExternalTask[].
+ *
+ * Optional: accepts a custom file path for testing.
+ *
+ * @remarks
+ * TodoWrite items with `[T001]`-style prefixes are mapped to their CLEO
+ * task IDs. Items without a prefix receive a synthetic `tw-new-N` ID
+ * for reconciliation. The provider reads from
+ * `.cleo/sync/todowrite-state.json` by default.
+ */
+export declare class ClaudeCodeTaskSyncProvider implements ExternalTaskProvider {
+    /** Optional override path for the TodoWrite state file (used in tests). */
+    private readonly customFilePath?;
+    constructor(options?: {
+        filePath?: string;
+    });
+    /** Retrieve external tasks from Claude's TodoWrite state file. */
+    getExternalTasks(projectDir: string): Promise<ExternalTask[]>;
+}
+//# sourceMappingURL=task-sync.d.ts.map

package/dist/providers/claude-code/task-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-sync.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/task-sync.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAsB,MAAM,qBAAqB,CAAC;AAkElG;;;;;;;;;;;;;GAaG;AACH,qBAAa,0BAA2B,YAAW,oBAAoB;IACrE,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAS;gBAE7B,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAI3C,kEAAkE;IAC5D,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;CAgDpE"}

package/dist/providers/claude-code/transport.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Transport provider for the Claude Code adapter.
+ *
+ * Implements AdapterTransportProvider to supply Claude Code's
+ * native inter-agent transport mechanism.
+ *
+ * @task T5240
+ */
+import type { AdapterTransportProvider } from '@cleocode/contracts';
+/**
+ * Transport provider for Claude Code inter-agent communication.
+ *
+ * @remarks
+ * Currently returns null from {@link createTransport} because actual transport
+ * creation is handled by the signaldock factory which checks for this adapter's
+ * transport capability flag. Full wiring will be completed in Phase 5 of the
+ * adapter system rollout.
+ */
+export declare class ClaudeCodeTransportProvider implements AdapterTransportProvider {
+    /** Provider-specific transport name used for capability negotiation. */
+    readonly transportName = "claude-code";
+    /** Create a transport instance for inter-agent messaging. */
+    createTransport(): unknown;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/providers/claude-code/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/providers/claude-code/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE;;;;;;;;GAQG;AACH,qBAAa,2BAA4B,YAAW,wBAAwB;IAC1E,wEAAwE;IACxE,QAAQ,CAAC,aAAa,iBAAiB;IAEvC,6DAA6D;IAC7D,eAAe,IAAI,OAAO;CAM3B"}