agentic-qe 3.8.4 → 3.8.5

package/dist/cli/commands/hooks-handlers/session-hooks.js

@@ -0,0 +1,171 @@
+/**
+ * Agentic QE v3 - Session Hooks (session-start, session-end)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles session lifecycle hooks.
+ */
+import chalk from 'chalk';
+import path from 'node:path';
+import { findProjectRoot } from '../../../kernel/unified-memory.js';
+import { state, getHooksSystem, createHybridBackendWithTimeout, consolidateExperiencesToPatterns, printJson, printSuccess, DREAM_STATE_KEY, } from './hooks-shared.js';
+/**
+ * Register session-start and session-end subcommands on the hooks command.
+ */
+export function registerSessionHooks(hooks) {
+    // -------------------------------------------------------------------------
+    // session-start: Initialize session state (called by SessionStart hook)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('session-start')
+        .description('Initialize session state when Claude Code session starts')
+        .option('-s, --session-id <id>', 'Session ID')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const sessionId = options.sessionId || `session-${Date.now()}`;
+            state.sessionId = sessionId;
+            // Initialize hooks system (lazy)
+            const { reasoningBank } = await getHooksSystem();
+            // Get initial stats for context
+            const stats = await reasoningBank.getStats();
+            // Initialize dream scheduler state for this session
+            const projectRoot = findProjectRoot();
+            const dataDir = path.join(projectRoot, '.agentic-qe');
+            const memoryBackend = await createHybridBackendWithTimeout(dataDir);
+            // Load existing dream state or create fresh one
+            let dreamState = await memoryBackend.get(DREAM_STATE_KEY);
+            const isNewSession = !dreamState || !dreamState.sessionStartTime;
+            if (!dreamState) {
+                dreamState = {
+                    lastDreamTime: null,
+                    experienceCount: 0,
+                    sessionStartTime: new Date().toISOString(),
+                    totalDreamsThisSession: 0,
+                };
+            }
+            else {
+                // Reset session counters but preserve lastDreamTime across sessions
+                dreamState.sessionStartTime = new Date().toISOString();
+                dreamState.totalDreamsThisSession = 0;
+                // Don't reset experienceCount — carry over unfulfilled experiences
+            }
+            await memoryBackend.set(DREAM_STATE_KEY, dreamState);
+            // Build context injection for Claude
+            const contextParts = [];
+            contextParts.push(`AQE Learning: ${stats.totalPatterns} patterns loaded`);
+            // Top domains by pattern count
+            const domainEntries = Object.entries(stats.byDomain)
+                .filter(([, count]) => count > 0)
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, 5);
+            if (domainEntries.length > 0) {
+                contextParts.push(`Top domains: ${domainEntries.map(([d, c]) => `${d}(${c})`).join(', ')}`);
+            }
+            if (stats.patternSuccessRate > 0) {
+                contextParts.push(`Pattern success rate: ${(stats.patternSuccessRate * 100).toFixed(0)}%`);
+            }
+            if (stats.routingRequests > 0) {
+                contextParts.push(`Routing confidence: ${(stats.avgRoutingConfidence * 100).toFixed(0)}% across ${stats.routingRequests} requests`);
+            }
+            const additionalContext = contextParts.join('. ') + '.';
+            if (options.json) {
+                printJson({
+                    hookSpecificOutput: {
+                        hookEventName: 'SessionStart',
+                        additionalContext,
+                    },
+                    sessionId,
+                    initialized: true,
+                    patternsLoaded: stats.totalPatterns,
+                    dreamScheduler: {
+                        enabled: true,
+                        lastDreamTime: dreamState.lastDreamTime,
+                        pendingExperiences: dreamState.experienceCount,
+                    },
+                });
+            }
+            else {
+                printSuccess(`Session started: ${sessionId}`);
+                console.log(chalk.dim(`  Patterns loaded: ${stats.totalPatterns}`));
+                console.log(chalk.dim(`  Dream scheduler: enabled (${dreamState.experienceCount} pending experiences)`));
+            }
+            return;
+        }
+        catch (error) {
+            // Don't fail the hook - just log and return cleanly
+            if (options.json) {
+                printJson({ success: false, error: error instanceof Error ? error.message : 'unknown' });
+            }
+            return; // Return cleanly even on error (continueOnError)
+        }
+    });
+    // -------------------------------------------------------------------------
+    // session-end: Save session state (called by Stop hook)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('session-end')
+        .description('Save session state when Claude Code session ends')
+        .option('--save-state', 'Save learning state to disk')
+        .option('--export-metrics', 'Export session metrics')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const sessionId = state.sessionId || 'unknown';
+            // Get final stats if system is already initialized (don't init just for shutdown)
+            let stats = null;
+            if (state.initialized && state.reasoningBank) {
+                try {
+                    stats = await state.reasoningBank.getStats();
+                }
+                catch {
+                    // Ignore - system may not be available during shutdown
+                }
+            }
+            // Run lightweight experience-to-pattern consolidation
+            let patternsCreated = 0;
+            try {
+                patternsCreated = await consolidateExperiencesToPatterns();
+            }
+            catch {
+                // Non-critical — don't block session end
+            }
+            if (options.json) {
+                const summary = stats
+                    ? `Session complete: ${stats.totalPatterns} patterns, ${stats.routingRequests} routings, ${(stats.patternSuccessRate * 100).toFixed(0)}% success rate`
+                    : 'Session complete';
+                // Stop hooks don't support hookSpecificOutput — only simple fields
+                printJson({
+                    continue: true,
+                    sessionId,
+                    stateSaved: options.saveState || false,
+                    metricsExported: options.exportMetrics || false,
+                    patternsConsolidated: patternsCreated,
+                    finalStats: stats ? {
+                        patternsLearned: stats.totalPatterns,
+                        routingRequests: stats.routingRequests,
+                        successRate: stats.patternSuccessRate,
+                    } : null,
+                });
+            }
+            else {
+                printSuccess(`Session ended: ${sessionId}`);
+                if (stats) {
+                    console.log(chalk.dim(`  Patterns: ${stats.totalPatterns}`));
+                    console.log(chalk.dim(`  Routing requests: ${stats.routingRequests}`));
+                }
+                if (patternsCreated > 0) {
+                    console.log(chalk.dim(`  Patterns consolidated: ${patternsCreated}`));
+                }
+            }
+            return;
+        }
+        catch (error) {
+            // Don't fail the hook - just return cleanly
+            if (options.json) {
+                printJson({ success: false, error: error instanceof Error ? error.message : 'unknown' });
+            }
+            return;
+        }
+    });
+}
+//# sourceMappingURL=session-hooks.js.map

package/dist/cli/commands/hooks-handlers/stats-hooks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agentic QE v3 - Stats Hooks (stats, list, emit, learn, search)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles pattern management and statistics subcommands.
+ */
+import { Command } from 'commander';
+/**
+ * Register stats, list, emit, learn, and search subcommands on the hooks command.
+ */
+export declare function registerStatsHooks(hooks: Command): void;
+//# sourceMappingURL=stats-hooks.d.ts.map

package/dist/cli/commands/hooks-handlers/stats-hooks.js

@@ -0,0 +1,248 @@
+/**
+ * Agentic QE v3 - Stats Hooks (stats, list, emit, learn, search)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles pattern management and statistics subcommands.
+ */
+import chalk from 'chalk';
+import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
+import { safeJsonParse } from '../../../shared/safe-json.js';
+import { getHooksSystem, printJson, printSuccess, printError, } from './hooks-shared.js';
+/**
+ * Register stats, list, emit, learn, and search subcommands on the hooks command.
+ */
+export function registerStatsHooks(hooks) {
+    // -------------------------------------------------------------------------
+    // stats: Get hooks system statistics
+    // -------------------------------------------------------------------------
+    hooks
+        .command('stats')
+        .description('Display hooks system statistics')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { reasoningBank } = await getHooksSystem();
+            const stats = await reasoningBank.getStats();
+            if (options.json) {
+                printJson(stats);
+            }
+            else {
+                console.log(chalk.bold('\n📊 Hooks System Statistics\n'));
+                console.log(chalk.bold('Patterns:'));
+                console.log(`  Total: ${chalk.cyan(stats.totalPatterns)}`);
+                console.log(`  Short-term: ${stats.patternStoreStats.byTier.shortTerm}`);
+                console.log(`  Long-term: ${stats.patternStoreStats.byTier.longTerm}`);
+                console.log(chalk.bold('\nBy Domain:'));
+                for (const [domain, count] of Object.entries(stats.byDomain)) {
+                    if (count > 0) {
+                        console.log(`  ${domain}: ${count}`);
+                    }
+                }
+                console.log(chalk.bold('\nRouting:'));
+                console.log(`  Requests: ${stats.routingRequests}`);
+                console.log(`  Avg Confidence: ${(stats.avgRoutingConfidence * 100).toFixed(1)}%`);
+                console.log(chalk.bold('\nLearning:'));
+                console.log(`  Outcomes: ${stats.learningOutcomes}`);
+                console.log(`  Success Rate: ${(stats.patternSuccessRate * 100).toFixed(1)}%`);
+                console.log(chalk.bold('\nSearch Performance:'));
+                console.log(`  Operations: ${stats.patternStoreStats.searchOperations}`);
+                console.log(`  Avg Latency: ${stats.patternStoreStats.avgSearchLatencyMs.toFixed(2)}ms`);
+                console.log(`  HNSW Native: ${stats.patternStoreStats.hnswStats.nativeAvailable ? '✓' : '✗'}`);
+            }
+        }
+        catch (error) {
+            printError(`stats failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // list: List registered hook events
+    // -------------------------------------------------------------------------
+    hooks
+        .command('list')
+        .description('List all registered QE hook events')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { hookRegistry } = await getHooksSystem();
+            const events = hookRegistry.getRegisteredEvents();
+            if (options.json) {
+                printJson({
+                    events,
+                    totalEvents: Object.keys(QE_HOOK_EVENTS).length,
+                    registeredEvents: events.length,
+                });
+            }
+            else {
+                console.log(chalk.bold('\n📋 Registered QE Hook Events\n'));
+                console.log(chalk.bold('All Available Events:'));
+                for (const [name, event] of Object.entries(QE_HOOK_EVENTS)) {
+                    const isRegistered = events.includes(event);
+                    const status = isRegistered ? chalk.green('✓') : chalk.dim('○');
+                    console.log(`  ${status} ${name}: ${chalk.dim(event)}`);
+                }
+                console.log(chalk.dim(`\nRegistered: ${events.length}/${Object.keys(QE_HOOK_EVENTS).length}`));
+            }
+        }
+        catch (error) {
+            printError(`list failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // emit: Emit a hook event (for testing/integration)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('emit')
+        .description('Emit a QE hook event')
+        .requiredOption('-e, --event <name>', 'Event name (e.g., qe:pattern-applied)')
+        .option('-d, --data <json>', 'Event data as JSON', '{}')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { hookRegistry } = await getHooksSystem();
+            let data;
+            try {
+                data = safeJsonParse(options.data);
+            }
+            catch {
+                throw new Error(`Invalid JSON data: ${options.data}`);
+            }
+            const results = await hookRegistry.emit(options.event, data);
+            if (options.json) {
+                printJson({
+                    event: options.event,
+                    results,
+                });
+            }
+            else {
+                console.log(chalk.bold('\n📡 Hook Event Emitted'));
+                console.log(chalk.dim(`  Event: ${options.event}`));
+                console.log(chalk.dim(`  Handlers: ${results.length}`));
+                results.forEach((result, i) => {
+                    const status = result.success ? chalk.green('✓') : chalk.red('✗');
+                    console.log(`  ${status} Handler ${i + 1}: ${result.success ? 'success' : result.error}`);
+                    if (result.patternsLearned) {
+                        console.log(chalk.green(`    Patterns learned: ${result.patternsLearned}`));
+                    }
+                });
+            }
+        }
+        catch (error) {
+            printError(`emit failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // learn: Store a new pattern for learning
+    // -------------------------------------------------------------------------
+    hooks
+        .command('learn')
+        .description('Store a new pattern in the reasoning bank')
+        .requiredOption('-n, --name <name>', 'Pattern name')
+        .requiredOption('-d, --description <desc>', 'Pattern description')
+        .option('-t, --type <type>', 'Pattern type', 'test-template')
+        .option('--domain <domain>', 'QE domain')
+        .option('--tags <tags...>', 'Pattern tags')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { reasoningBank } = await getHooksSystem();
+            const result = await reasoningBank.storePattern({
+                patternType: options.type,
+                name: options.name,
+                description: options.description,
+                template: {
+                    type: 'prompt',
+                    content: options.description,
+                    variables: [],
+                },
+                context: {
+                    tags: options.tags || [],
+                },
+            });
+            if (!result.success) {
+                throw new Error(result.error.message);
+            }
+            const pattern = result.value;
+            if (options.json) {
+                printJson({
+                    success: true,
+                    pattern: {
+                        id: pattern.id,
+                        name: pattern.name,
+                        type: pattern.patternType,
+                        domain: pattern.qeDomain,
+                    },
+                });
+            }
+            else {
+                printSuccess(`Pattern stored: ${pattern.name}`);
+                console.log(chalk.dim(`  ID: ${pattern.id}`));
+                console.log(chalk.dim(`  Domain: ${pattern.qeDomain}`));
+                console.log(chalk.dim(`  Tier: ${pattern.tier}`));
+            }
+        }
+        catch (error) {
+            printError(`learn failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // search: Search for patterns
+    // -------------------------------------------------------------------------
+    hooks
+        .command('search')
+        .description('Search for patterns in the reasoning bank')
+        .requiredOption('-q, --query <query>', 'Search query')
+        .option('-l, --limit <n>', 'Maximum results', '10')
+        .option('-d, --domain <domain>', 'Filter by domain')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { reasoningBank } = await getHooksSystem();
+            const result = await reasoningBank.searchPatterns(options.query, {
+                limit: parseInt(options.limit, 10),
+                domain: options.domain,
+            });
+            if (!result.success) {
+                throw new Error(result.error.message);
+            }
+            const patterns = result.value;
+            if (options.json) {
+                printJson({
+                    query: options.query,
+                    total: patterns.length,
+                    patterns: patterns.map((p) => ({
+                        id: p.pattern.id,
+                        name: p.pattern.name,
+                        score: p.score,
+                        domain: p.pattern.qeDomain,
+                        matchType: p.matchType,
+                    })),
+                });
+            }
+            else {
+                console.log(chalk.bold(`\n🔍 Search Results for "${options.query}"\n`));
+                if (patterns.length === 0) {
+                    console.log(chalk.dim('  No patterns found'));
+                }
+                else {
+                    patterns.forEach((p, i) => {
+                        console.log(`${chalk.cyan(`${i + 1}.`)} ${p.pattern.name} ${chalk.dim(`(${(p.score * 100).toFixed(1)}%)`)}`);
+                        console.log(chalk.dim(`   Domain: ${p.pattern.qeDomain}`));
+                        console.log(chalk.dim(`   Match: ${p.matchType}`));
+                        console.log(chalk.dim(`   ID: ${p.pattern.id}`));
+                        console.log();
+                    });
+                }
+                console.log(chalk.dim(`Found ${patterns.length} pattern(s)`));
+            }
+        }
+        catch (error) {
+            printError(`search failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=stats-hooks.js.map

package/dist/cli/commands/hooks-handlers/task-hooks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agentic QE v3 - Task Hooks (pre-task, post-task)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles task lifecycle hooks for pattern learning.
+ */
+import { Command } from 'commander';
+/**
+ * Register pre-task and post-task subcommands on the hooks command.
+ */
+export declare function registerTaskHooks(hooks: Command): void;
+//# sourceMappingURL=task-hooks.d.ts.map

package/dist/cli/commands/hooks-handlers/task-hooks.js

@@ -0,0 +1,152 @@
+/**
+ * Agentic QE v3 - Task Hooks (pre-task, post-task)
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Handles task lifecycle hooks for pattern learning.
+ */
+import chalk from 'chalk';
+import path from 'node:path';
+import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
+import { findProjectRoot } from '../../../kernel/unified-memory.js';
+import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, checkAndTriggerDream, printJson, printSuccess, } from './hooks-shared.js';
+/**
+ * Register pre-task and post-task subcommands on the hooks command.
+ */
+export function registerTaskHooks(hooks) {
+    // -------------------------------------------------------------------------
+    // pre-task: Get guidance before spawning a Task (called by PreToolUse hook)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('pre-task')
+        .description('Get context and guidance before spawning a Task agent')
+        .option('--task-id <id>', 'Task identifier')
+        .option('-d, --description <desc>', 'Task description')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const { reasoningBank } = await getHooksSystem();
+            // Route the task to get agent recommendation
+            let routing = null;
+            if (options.description) {
+                const result = await reasoningBank.routeTask({
+                    task: options.description,
+                });
+                if (result.success) {
+                    routing = result.value;
+                }
+            }
+            if (options.json) {
+                printJson({
+                    success: true,
+                    taskId: options.taskId,
+                    description: options.description,
+                    recommendedAgent: routing?.recommendedAgent,
+                    confidence: routing?.confidence,
+                    guidance: routing?.guidance || [],
+                });
+            }
+            else {
+                console.log(chalk.bold('\n🚀 Pre-Task Analysis'));
+                console.log(chalk.dim(`  Task ID: ${options.taskId || 'N/A'}`));
+                if (routing) {
+                    console.log(chalk.bold('\n🎯 Recommended:'), chalk.cyan(routing.recommendedAgent));
+                    console.log(chalk.dim(`  Confidence: ${(routing.confidence * 100).toFixed(1)}%`));
+                }
+            }
+            return;
+        }
+        catch (error) {
+            if (options.json) {
+                printJson({ success: false, error: error instanceof Error ? error.message : 'unknown' });
+            }
+            return;
+        }
+    });
+    // -------------------------------------------------------------------------
+    // post-task: Record task outcome for learning (called by PostToolUse hook)
+    // -------------------------------------------------------------------------
+    hooks
+        .command('post-task')
+        .description('Record task outcome for pattern learning')
+        .option('--task-id <id>', 'Task identifier')
+        .option('--success <bool>', 'Whether task succeeded', 'true')
+        .option('--agent <name>', 'Agent that executed the task')
+        .option('--duration <ms>', 'Task duration in milliseconds')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const success = options.success === 'true' || options.success === true;
+            // Initialize hooks system and record learning outcome
+            // BUG FIX: Must call getHooksSystem() FIRST to initialize, not check state.initialized
+            let patternsLearned = 0;
+            let dreamResult = { triggered: false };
+            try {
+                // Initialize system (creates ReasoningBank and HookRegistry)
+                const { hookRegistry, reasoningBank } = await getHooksSystem();
+                // Emit learning event for task completion
+                const results = await hookRegistry.emit(QE_HOOK_EVENTS.QEAgentCompletion, {
+                    taskId: options.taskId,
+                    success,
+                    agent: options.agent,
+                    duration: options.duration ? parseInt(options.duration, 10) : undefined,
+                    timestamp: Date.now(),
+                });
+                patternsLearned = results.reduce((sum, r) => sum + (r.patternsLearned || 0), 0);
+                // Record as learning experience for every post-task invocation
+                if (options.taskId) {
+                    const agent = options.agent || 'unknown';
+                    await reasoningBank.recordOutcome({
+                        patternId: `task:${agent}:${options.taskId}`,
+                        success,
+                        metrics: {
+                            executionTimeMs: options.duration ? parseInt(options.duration, 10) : 0,
+                        },
+                        feedback: `Agent: ${agent}, Task: ${options.taskId}`,
+                    });
+                }
+                // Record experience for dream scheduler and check if dream should trigger
+                const projectRoot = findProjectRoot();
+                const dataDir = path.join(projectRoot, '.agentic-qe');
+                const memoryBackend = await createHybridBackendWithTimeout(dataDir);
+                const expCount = await incrementDreamExperience(memoryBackend);
+                // Check if dream cycle should be triggered
+                // Always check — time-based triggers need every invocation, and the
+                // check itself is lightweight (just reads state + compares timestamps)
+                dreamResult = await checkAndTriggerDream(memoryBackend);
+            }
+            catch (initError) {
+                // Log but don't fail - learning is best-effort
+                console.error(chalk.dim(`[hooks] Learning init: ${initError instanceof Error ? initError.message : 'unknown'}`));
+            }
+            if (options.json) {
+                printJson({
+                    success: true,
+                    taskId: options.taskId,
+                    taskSuccess: success,
+                    patternsLearned,
+                    dreamTriggered: dreamResult.triggered,
+                    dreamReason: dreamResult.reason,
+                    dreamInsights: dreamResult.insightsGenerated,
+                });
+            }
+            else {
+                printSuccess(`Task completed: ${options.taskId || 'unknown'}`);
+                console.log(chalk.dim(`  Success: ${success}`));
+                if (patternsLearned > 0) {
+                    console.log(chalk.green(`  Patterns learned: ${patternsLearned}`));
+                }
+                if (dreamResult.triggered) {
+                    console.log(chalk.blue(`  🌙 Dream cycle triggered (${dreamResult.reason}): ${dreamResult.insightsGenerated} insights`));
+                }
+            }
+            return;
+        }
+        catch (error) {
+            if (options.json) {
+                printJson({ success: false, error: error instanceof Error ? error.message : 'unknown' });
+            }
+            return;
+        }
+    });
+}
+//# sourceMappingURL=task-hooks.js.map

package/dist/cli/commands/hooks.d.ts

@@ -4,31 +4,11 @@
  * ADR-021: QE ReasoningBank for Pattern Learning
  *
  * Self-learning hooks system for pattern recognition and guidance generation.
- * This module provides CLI commands for the QE hooks system.
+ * This module composes all hooks subcommands from per-handler modules.
  */
 import { Command } from 'commander';
-import { QEReasoningBank } from '../../learning/qe-reasoning-bank.js';
-import { QEHookRegistry, QE_HOOK_EVENTS } from '../../learning/qe-hooks.js';
-import { type ICoherenceService } from '../../integrations/coherence/index.js';
-/**
- * Singleton state for hooks system
- */
-interface HooksSystemState {
-    reasoningBank: QEReasoningBank | null;
-    hookRegistry: QEHookRegistry | null;
-    coherenceService: ICoherenceService | null;
-    sessionId: string | null;
-    initialized: boolean;
-    initializationPromise: Promise<void> | null;
-}
-declare const state: HooksSystemState;
-/**
- * Get or create the hooks system with proper initialization
- */
-declare function getHooksSystem(): Promise<{
-    reasoningBank: QEReasoningBank;
-    hookRegistry: QEHookRegistry;
-}>;
+import { QE_HOOK_EVENTS } from '../../learning/qe-hooks.js';
+import { getHooksSystem, state, type HooksSystemState } from './hooks-handlers/hooks-shared.js';
 /**
  * Create the hooks command with all subcommands
  */