@rulecatch/ai-pooler 0.4.0

package/dist/cli.js

@@ -0,0 +1,1338 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import { existsSync, unlinkSync, rmSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, chmodSync } from 'fs';
+import * as os from 'os';
+import { homedir } from 'os';
+import * as path from 'path';
+import { join, dirname } from 'path';
+import { randomBytes, pbkdf2Sync, createDecipheriv } from 'crypto';
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+
+/**
+ * Rulecatch AI Pooler initialization
+ * Interactive setup: API key validation, encryption, hook installation
+ */
+// Paths
+const CLAUDE_DIR$1 = join(homedir(), '.claude');
+const HOOKS_DIR = join(CLAUDE_DIR$1, 'hooks');
+const RULECATCH_DIR$2 = join(CLAUDE_DIR$1, 'rulecatch');
+const CONFIG_PATH$1 = join(RULECATCH_DIR$2, 'config.json');
+const BUFFER_DIR$1 = join(RULECATCH_DIR$2, 'buffer');
+const SETTINGS_PATH$1 = join(CLAUDE_DIR$1, 'settings.json');
+const HOOK_SCRIPT_DEST = join(HOOKS_DIR, 'rulecatch-track.sh');
+const FLUSH_SCRIPT_DEST = join(HOOKS_DIR, 'rulecatch-flush.js');
+const MCP_SERVER_DEST = join(RULECATCH_DIR$2, 'mcp-server.js');
+// Colors
+const green$1 = (s) => `\x1b[32m${s}\x1b[0m`;
+const red$1 = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow$1 = (s) => `\x1b[33m${s}\x1b[0m`;
+const dim$1 = (s) => `\x1b[2m${s}\x1b[0m`;
+function prompt(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function promptPassword(promptText) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode?.(true);
+        }
+        process.stdout.write(promptText);
+        let password = '';
+        const onData = (char) => {
+            const c = char.toString();
+            if (c === '\n' || c === '\r') {
+                process.stdin.removeListener('data', onData);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode?.(false);
+                }
+                process.stdout.write('\n');
+                rl.close();
+                resolve(password);
+            }
+            else if (c === '\u0003') {
+                process.exit(0);
+            }
+            else if (c === '\u007F' || c === '\b') {
+                if (password.length > 0) {
+                    password = password.slice(0, -1);
+                    process.stdout.write('\b \b');
+                }
+            }
+            else {
+                password += c;
+                process.stdout.write('*');
+            }
+        };
+        process.stdin.on('data', onData);
+        process.stdin.resume();
+    });
+}
+async function validateApiKey(apiKey) {
+    try {
+        const response = await fetch('https://api.rulecatch.ai/api/v1/ai/validate-key', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ apiKey }),
+        });
+        if (!response.ok) {
+            return { valid: false };
+        }
+        return await response.json();
+    }
+    catch {
+        // API unreachable - allow setup anyway (offline mode)
+        return { valid: true, region: 'us', plan: 'unknown', daysRemaining: -1 };
+    }
+}
+function findFile(filename) {
+    const base = dirname(new URL(import.meta.url).pathname);
+    const candidates = [
+        join(base, '..', 'templates', filename),
+        join(base, '..', '..', 'templates', filename),
+        join(base, 'templates', filename),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+function findFlushScript() {
+    const base = dirname(new URL(import.meta.url).pathname);
+    const candidates = [
+        join(base, 'flush.js'),
+        join(base, '..', 'dist', 'flush.js'),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+function findMcpServer() {
+    const base = dirname(new URL(import.meta.url).pathname);
+    const candidates = [
+        // Built MCP server (from packages/mcp-server/dist/)
+        join(base, '..', '..', 'mcp-server', 'dist', 'index.js'),
+        // Already installed
+        join(RULECATCH_DIR$2, 'mcp-server.js'),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+async function init(options = {}) {
+    console.log('\nRulecatch AI Analytics Setup');
+    console.log('----------------------------\n');
+    // 0. Check if user has an account
+    if (!options.apiKey) {
+        const hasAccount = await prompt('Do you have a RuleCatch account?\n' +
+            '  1) Yes, I have an API key\n' +
+            '  2) No, I need to create an account\n' +
+            '> ');
+        if (hasAccount === '2' || hasAccount.toLowerCase().startsWith('n')) {
+            console.log('\nOpening RuleCatch signup in your browser...');
+            console.log('After creating an account, run this command again with your API key.\n');
+            // Open browser to signup page
+            const signupUrl = 'https://dashboard.rulecatch.ai/signup';
+            try {
+                const { exec } = await import('child_process');
+                const platform = process.platform;
+                if (platform === 'darwin') {
+                    exec(`open "${signupUrl}"`);
+                }
+                else if (platform === 'win32') {
+                    exec(`start "" "${signupUrl}"`);
+                }
+                else {
+                    // Linux and others
+                    exec(`xdg-open "${signupUrl}" 2>/dev/null || sensible-browser "${signupUrl}" 2>/dev/null || x-www-browser "${signupUrl}" 2>/dev/null || echo "Please open: ${signupUrl}"`);
+                }
+                console.log(`${dim$1('If browser didn\'t open, visit:')} ${signupUrl}\n`);
+            }
+            catch {
+                console.log(`Visit: ${signupUrl}\n`);
+            }
+            process.exit(0);
+        }
+    }
+    // 1. Get API key
+    let apiKey = options.apiKey;
+    if (!apiKey) {
+        apiKey = await prompt('Enter your API key (get one at https://dashboard.rulecatch.ai):\n> ');
+    }
+    if (!apiKey || !apiKey.startsWith('dc_')) {
+        console.log(red$1('\nInvalid API key. Keys start with "dc_".'));
+        process.exit(1);
+    }
+    // 2. Validate API key
+    process.stdout.write('Validating API key... ');
+    const validation = await validateApiKey(apiKey);
+    if (!validation.valid) {
+        console.log(red$1('Invalid'));
+        console.log(red$1('\nAPI key is not valid. Get a key at https://dashboard.rulecatch.ai\n'));
+        process.exit(1);
+    }
+    const region = options.region || validation.region || 'us';
+    const planInfo = validation.plan || 'unknown';
+    const daysInfo = validation.daysRemaining && validation.daysRemaining > 0
+        ? ` - ${validation.daysRemaining} days remaining`
+        : '';
+    console.log(green$1(`Valid (${planInfo}${daysInfo})`));
+    console.log(`Region: ${region === 'eu' ? 'EU (Frankfurt)' : 'US (Virginia)'} - set in your dashboard account\n`);
+    // 3. Get encryption password
+    let encryptionPassword;
+    let autoGeneratedKey = false;
+    if (options.encryptionKey) {
+        // Passed via --encryption-key flag (e.g. easy AI install mode)
+        encryptionPassword = options.encryptionKey;
+        if (encryptionPassword.length < 8) {
+            console.log(red$1('\nEncryption key must be at least 8 characters.\n'));
+            process.exit(1);
+        }
+        console.log(green$1('+ Encryption key set from --encryption-key flag'));
+        console.log(dim$1("Use this same key in the dashboard to decrypt your personal data.\n"));
+    }
+    else if (process.stdin.isTTY) {
+        encryptionPassword = await promptPassword('Enter an encryption password (used locally to encrypt PII before sending):\n> ');
+        if (encryptionPassword.length < 8) {
+            console.log(red$1('\nPassword must be at least 8 characters.\n'));
+            process.exit(1);
+        }
+        console.log(dim$1("\nYou'll need this same password in the dashboard to decrypt your personal data.\n"));
+    }
+    else {
+        encryptionPassword = randomBytes(32).toString('base64');
+        autoGeneratedKey = true;
+        console.log(dim$1('Non-interactive mode: auto-generated encryption password.'));
+        console.log(dim$1('Retrieve it with: npx @rulecatch/ai-pooler config --show-key\n'));
+    }
+    // 4. Create config
+    const salt = randomBytes(32).toString('base64');
+    const config = {
+        apiKey,
+        region,
+        batchSize: options.batchSize || 20,
+        salt,
+        encryptionKey: encryptionPassword,
+        ...(autoGeneratedKey && { autoGeneratedKey: true }),
+    };
+    // 5. Create directory structure
+    mkdirSync(RULECATCH_DIR$2, { recursive: true });
+    mkdirSync(BUFFER_DIR$1, { recursive: true });
+    mkdirSync(HOOKS_DIR, { recursive: true });
+    // 6. Write config
+    writeFileSync(CONFIG_PATH$1, JSON.stringify(config, null, 2), { mode: 0o600 });
+    console.log(green$1('+ Config saved to ~/.claude/rulecatch/config.json'));
+    // 7. Copy hook script from template
+    const hookTemplate = findFile('rulecatch-track.sh');
+    if (hookTemplate) {
+        copyFileSync(hookTemplate, HOOK_SCRIPT_DEST);
+        chmodSync(HOOK_SCRIPT_DEST, 0o755);
+        console.log(green$1('+ Hook script installed to ~/.claude/hooks/rulecatch-track.sh'));
+    }
+    else {
+        console.log(yellow$1('! Hook script template not found. You may need to reinstall.'));
+    }
+    // 8. Copy flush script
+    const flushSource = findFlushScript();
+    if (flushSource) {
+        copyFileSync(flushSource, FLUSH_SCRIPT_DEST);
+        chmodSync(FLUSH_SCRIPT_DEST, 0o755);
+        console.log(green$1('+ Flush script installed to ~/.claude/hooks/rulecatch-flush.js'));
+    }
+    else {
+        console.log(yellow$1('! Flush script not found. Run `pnpm build` first if developing locally.'));
+    }
+    // 9. Copy MCP server
+    const mcpServerSource = findMcpServer();
+    if (mcpServerSource) {
+        copyFileSync(mcpServerSource, MCP_SERVER_DEST);
+        console.log(green$1('+ MCP server installed to ~/.claude/rulecatch/mcp-server.js'));
+    }
+    else {
+        console.log(yellow$1('! MCP server not found. MCP tools will not be available.'));
+    }
+    // 10. Register hooks + MCP server in settings.json
+    registerHooks(!!mcpServerSource);
+    console.log(green$1('+ Hooks registered in ~/.claude/settings.json'));
+    if (mcpServerSource) {
+        console.log(green$1('+ MCP server registered in ~/.claude/settings.json'));
+    }
+    console.log(green$1('\n+ Setup complete!') + ' Hooks activate on your next Claude Code session.');
+    console.log('  If Claude is running now, type /exit and reopen to activate.\n');
+}
+function registerHooks(includeMcpServer = false) {
+    let settings = {};
+    if (existsSync(SETTINGS_PATH$1)) {
+        try {
+            settings = JSON.parse(readFileSync(SETTINGS_PATH$1, 'utf-8'));
+        }
+        catch {
+            // Start fresh
+        }
+    }
+    const hookConfig = {
+        hooks: [
+            {
+                type: 'command',
+                command: HOOK_SCRIPT_DEST,
+                timeout: 10,
+            },
+        ],
+    };
+    settings.hooks = {
+        SessionStart: [{ ...hookConfig }],
+        SessionEnd: [{ ...hookConfig }],
+        PostToolUse: [{ matcher: '*', ...hookConfig }],
+        PostToolUseFailure: [{ matcher: '*', ...hookConfig }],
+        Stop: [{ ...hookConfig }],
+    };
+    // Register MCP server so Claude Code can use Rulecatch tools
+    if (includeMcpServer) {
+        const mcpServers = (settings.mcpServers || {});
+        mcpServers.rulecatch = {
+            command: 'node',
+            args: [MCP_SERVER_DEST],
+        };
+        settings.mcpServers = mcpServers;
+    }
+    // Remove old RULECATCH_*/DWELLCOUNT_* env vars (cleanup)
+    if (settings.env && typeof settings.env === 'object') {
+        const env = settings.env;
+        for (const key of Object.keys(env)) {
+            if (key.startsWith('RULECATCH_') || key.startsWith('DWELLCOUNT_')) {
+                delete env[key];
+            }
+        }
+        if (Object.keys(env).length === 0) {
+            delete settings.env;
+        }
+    }
+    writeFileSync(SETTINGS_PATH$1, JSON.stringify(settings, null, 2));
+}
+function uninstall() {
+    console.log('\nRemoving Rulecatch tracking...\n');
+    // Remove hook script
+    if (existsSync(HOOK_SCRIPT_DEST)) {
+        unlinkSync(HOOK_SCRIPT_DEST);
+        console.log(green$1('+ Removed hook script'));
+    }
+    // Remove flush script
+    if (existsSync(FLUSH_SCRIPT_DEST)) {
+        unlinkSync(FLUSH_SCRIPT_DEST);
+        console.log(green$1('+ Removed flush script'));
+    }
+    // Remove old hook script name
+    const oldHookPath = join(HOOKS_DIR, 'dwellcount-track.sh');
+    if (existsSync(oldHookPath)) {
+        unlinkSync(oldHookPath);
+        console.log(green$1('+ Removed old hook script (dwellcount-track.sh)'));
+    }
+    // Remove entire rulecatch directory
+    if (existsSync(RULECATCH_DIR$2)) {
+        rmSync(RULECATCH_DIR$2, { recursive: true, force: true });
+        console.log(green$1('+ Removed ~/.claude/rulecatch/ directory'));
+    }
+    // Remove old config files
+    for (const oldFile of ['rulecatch.json', 'rulecatch-privacy.json', '.rulecatch-key']) {
+        const p = join(CLAUDE_DIR$1, oldFile);
+        if (existsSync(p)) {
+            unlinkSync(p);
+            console.log(green$1(`+ Removed old file: ${oldFile}`));
+        }
+    }
+    // Clean settings.json
+    if (existsSync(SETTINGS_PATH$1)) {
+        try {
+            const settings = JSON.parse(readFileSync(SETTINGS_PATH$1, 'utf-8'));
+            delete settings.hooks;
+            if (settings.env) {
+                for (const key of Object.keys(settings.env)) {
+                    if (key.startsWith('RULECATCH_') || key.startsWith('DWELLCOUNT_')) {
+                        delete settings.env[key];
+                    }
+                }
+                if (Object.keys(settings.env).length === 0) {
+                    delete settings.env;
+                }
+            }
+            writeFileSync(SETTINGS_PATH$1, JSON.stringify(settings, null, 2));
+            console.log(green$1('+ Cleaned up settings.json'));
+        }
+        catch {
+            console.log(yellow$1('! Could not update settings.json'));
+        }
+    }
+    console.log(green$1('\n+ Rulecatch tracking removed.\n'));
+}
+
+/**
+ * Backpressure & Flow Control for Rulecatch AI Pooler
+ *
+ * Implements smart throttling that:
+ * 1. Asks server "how much can I send?" before flushing
+ * 2. Respects rate limits (429) with exponential backoff
+ * 3. Gradually drains buffer when server recovers
+ * 4. Prevents thundering herd after outages
+ */
+// Paths
+const RULECATCH_DIR$1 = join(homedir(), '.claude', 'rulecatch');
+const BACKPRESSURE_STATE_FILE$1 = join(RULECATCH_DIR$1, '.backpressure-state');
+join(RULECATCH_DIR$1, 'flush.log');
+/**
+ * Load persisted backpressure state
+ */
+function loadState() {
+    try {
+        if (existsSync(BACKPRESSURE_STATE_FILE$1)) {
+            const content = readFileSync(BACKPRESSURE_STATE_FILE$1, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Corrupt state, start fresh
+    }
+    return {
+        backoffLevel: 0,
+        nextAttemptAfter: 0,
+        lastCapacity: null,
+        consecutiveFailures: 0,
+        lastSuccessTime: 0,
+        pendingEventCount: 0,
+    };
+}
+
+/**
+ * Rulecatch AI Pooler - Zero Token Overhead Tracking
+ *
+ * Commands:
+ *   npx @rulecatch/ai-pooler init        - Interactive setup
+ *   npx @rulecatch/ai-pooler uninstall   - Remove everything
+ *   npx @rulecatch/ai-pooler status      - Check setup and buffer
+ *   npx @rulecatch/ai-pooler flush       - Force flush buffered events
+ *   npx @rulecatch/ai-pooler logs        - Show flush activity logs
+ *   npx @rulecatch/ai-pooler config      - Update configuration
+ *   npx @rulecatch/ai-pooler monitor     - Live event stream (alias: live)
+ *     -v / --verbose                     - Show file paths, git context
+ *     -vv / --debug                      - Full JSON event dump
+ *   npx @rulecatch/ai-pooler backpressure - Show backpressure status
+ */
+const args = process.argv.slice(2);
+const command = args[0];
+// Colors
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+// Paths
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const RULECATCH_DIR = path.join(CLAUDE_DIR, 'rulecatch');
+const CONFIG_PATH = path.join(RULECATCH_DIR, 'config.json');
+const BUFFER_DIR = path.join(RULECATCH_DIR, 'buffer');
+const LOG_FILE = path.join(RULECATCH_DIR, 'flush.log');
+const HOOK_LOG = '/tmp/rulecatch-hook.log';
+const SESSION_FILE = path.join(RULECATCH_DIR, '.session');
+const HOOK_SCRIPT = path.join(CLAUDE_DIR, 'hooks', 'rulecatch-track.sh');
+const FLUSH_SCRIPT = path.join(CLAUDE_DIR, 'hooks', 'rulecatch-flush.js');
+const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const BACKPRESSURE_STATE_FILE = path.join(RULECATCH_DIR, '.backpressure-state');
+const PAUSED_FILE = path.join(RULECATCH_DIR, '.paused');
+function parseArgs() {
+    const result = {};
+    for (const arg of args) {
+        if (arg.startsWith('--')) {
+            const [key, value] = arg.slice(2).split('=');
+            if (key && value) {
+                result[key.replace(/-/g, '')] = value;
+            }
+        }
+    }
+    return result;
+}
+function getBufferCount() {
+    try {
+        if (!fs.existsSync(BUFFER_DIR))
+            return 0;
+        return fs.readdirSync(BUFFER_DIR).filter(f => f.endsWith('.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function main() {
+    switch (command) {
+        case 'init': {
+            const flags = parseArgs();
+            await init({
+                apiKey: flags.apikey || flags.key,
+                region: flags.region || undefined,
+                batchSize: flags.batchsize ? parseInt(flags.batchsize, 10) : undefined,
+                encryptionKey: flags.encryptionkey,
+            });
+            break;
+        }
+        case 'uninstall':
+        case 'remove': {
+            uninstall();
+            break;
+        }
+        case 'status': {
+            console.log('\nRulecatch Status\n');
+            // Check if paused due to subscription
+            if (fs.existsSync(PAUSED_FILE)) {
+                try {
+                    const pausedInfo = JSON.parse(fs.readFileSync(PAUSED_FILE, 'utf-8'));
+                    console.log(`Collection:    ${red('⏸ PAUSED')}`);
+                    console.log(`  Reason:      ${dim(pausedInfo.reason || 'subscription_expired')}`);
+                    console.log(`  Since:       ${dim(pausedInfo.pausedAt || 'unknown')}`);
+                    console.log(`  ${yellow('Run `npx @rulecatch/ai-pooler reactivate` after subscribing')}\n`);
+                }
+                catch {
+                    console.log(`Collection:    ${red('⏸ PAUSED')} (corrupt file)\n`);
+                }
+            }
+            else {
+                console.log(`Collection:    ${green('+ Active')}\n`);
+            }
+            // Check config
+            if (fs.existsSync(CONFIG_PATH)) {
+                try {
+                    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+                    console.log(`Config:        ${green('+ Found')}`);
+                    console.log(`  API key:     ${dim(config.apiKey?.slice(0, 8) + '...')}`);
+                    console.log(`  Region:      ${dim(config.region === 'eu' ? 'EU (Frankfurt)' : 'US (Virginia)')}`);
+                    console.log(`  Batch size:  ${dim(String(config.batchSize || 20))}`);
+                    console.log(`  Encrypted:   ${config.encryptionKey ? green('Yes') : yellow('No')}`);
+                }
+                catch {
+                    console.log(`Config:        ${red('x Parse error')}`);
+                }
+            }
+            else {
+                console.log(`Config:        ${red('x Not found')}`);
+                console.log(dim('  Run `npx @rulecatch/ai-pooler init` to set up.\n'));
+                break;
+            }
+            // Check hook script
+            console.log(`\nHook script:   ${fs.existsSync(HOOK_SCRIPT) ? green('+ Installed') : red('x Not found')}`);
+            console.log(`Flush script:  ${fs.existsSync(FLUSH_SCRIPT) ? green('+ Installed') : red('x Not found')}`);
+            // Check hooks in settings.json
+            let hooksConfigured = false;
+            if (fs.existsSync(SETTINGS_PATH)) {
+                try {
+                    const settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8'));
+                    hooksConfigured = !!settings.hooks?.PostToolUse;
+                }
+                catch { /* ignore */ }
+            }
+            console.log(`Hooks config:  ${hooksConfigured ? green('+ Registered') : red('x Not registered')}`);
+            // Buffer status
+            const bufferCount = getBufferCount();
+            console.log(`\nBuffer:        ${bufferCount} events pending`);
+            // Session token
+            if (fs.existsSync(SESSION_FILE)) {
+                try {
+                    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+                    const expiresIn = Math.max(0, Math.round((session.expiry - Date.now()) / 1000 / 60));
+                    console.log(`Session token: ${green('+ Valid')} (expires in ${expiresIn}m)`);
+                }
+                catch {
+                    console.log(`Session token: ${yellow('o Expired/corrupt')}`);
+                }
+            }
+            else {
+                console.log(`Session token: ${dim('Not acquired yet')}`);
+            }
+            // Hook log
+            if (fs.existsSync(HOOK_LOG)) {
+                const lines = fs.readFileSync(HOOK_LOG, 'utf-8').trim().split('\n');
+                const lastLine = lines[lines.length - 1] || '';
+                console.log(`\nHook log:      ${green('+ Active')} (${lines.length} entries)`);
+                console.log(`Last activity: ${dim(lastLine)}`);
+            }
+            else {
+                console.log(`\nHook log:      ${yellow('o No activity yet')}`);
+            }
+            // Backpressure status (brief summary)
+            const bpState = loadState();
+            if (bpState.consecutiveFailures > 0 || bpState.backoffLevel > 0) {
+                console.log(`\nBackpressure:  ${yellow('o Active')}`);
+                if (bpState.consecutiveFailures > 0) {
+                    console.log(`  Failures:    ${bpState.consecutiveFailures} consecutive`);
+                }
+                if (bpState.backoffLevel > 0) {
+                    console.log(`  Backoff:     Level ${bpState.backoffLevel}/10`);
+                }
+                if (bpState.nextAttemptAfter > Date.now()) {
+                    const waitSec = Math.ceil((bpState.nextAttemptAfter - Date.now()) / 1000);
+                    console.log(`  Next retry:  ${waitSec}s`);
+                }
+                console.log(dim('  Run `npx @rulecatch/ai-pooler backpressure` for details'));
+            }
+            else {
+                console.log(`\nBackpressure:  ${green('+ Healthy')}`);
+            }
+            console.log('');
+            break;
+        }
+        case 'flush': {
+            console.log('\nFlushing buffered events...\n');
+            const bufferCount = getBufferCount();
+            if (bufferCount === 0) {
+                console.log(yellow('No events in buffer.\n'));
+                break;
+            }
+            console.log(`${bufferCount} events in buffer.`);
+            if (fs.existsSync(FLUSH_SCRIPT)) {
+                try {
+                    execSync(`node "${FLUSH_SCRIPT}" --force`, { stdio: 'inherit' });
+                    const remaining = getBufferCount();
+                    if (remaining === 0) {
+                        console.log(green('\n+ All events flushed.\n'));
+                    }
+                    else {
+                        console.log(yellow(`\n${remaining} events remaining (API may be unreachable).\n`));
+                    }
+                }
+                catch {
+                    console.log(red('\nFlush failed. Check logs with `npx @rulecatch/ai-pooler logs`.\n'));
+                }
+            }
+            else {
+                console.log(red('Flush script not found. Run `npx @rulecatch/ai-pooler init` to reinstall.\n'));
+            }
+            break;
+        }
+        case 'logs': {
+            const flags = parseArgs();
+            const lineCount = parseInt(flags.lines || '30', 10);
+            const source = flags.source || 'flush';
+            const logPath = source === 'hook' ? HOOK_LOG : LOG_FILE;
+            const label = source === 'hook' ? 'Hook' : 'Flush';
+            console.log(`\nRulecatch ${label} Logs (last ${lineCount} entries)\n`);
+            if (fs.existsSync(logPath)) {
+                const content = fs.readFileSync(logPath, 'utf-8').trim().split('\n');
+                const recent = content.slice(-lineCount);
+                recent.forEach((line) => console.log(dim(line)));
+                console.log(`\n${dim(`Total entries: ${content.length}`)}`);
+                console.log(`${dim(`Log file: ${logPath}`)}\n`);
+            }
+            else {
+                console.log(yellow(`No ${label.toLowerCase()} log found.`));
+                console.log('No events have been processed yet.\n');
+            }
+            break;
+        }
+        case 'config': {
+            const flags = parseArgs();
+            if (!fs.existsSync(CONFIG_PATH)) {
+                console.log(red('\nNot configured. Run `npx @rulecatch/ai-pooler init` first.\n'));
+                process.exit(1);
+            }
+            const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            let changed = false;
+            if (flags.batchsize) {
+                config.batchSize = parseInt(flags.batchsize, 10);
+                changed = true;
+            }
+            if (flags.region && (flags.region === 'us' || flags.region === 'eu')) {
+                config.region = flags.region;
+                changed = true;
+            }
+            if (flags.showkey === 'true' || args.includes('--show-key')) {
+                if (config.encryptionKey) {
+                    console.log('\nYour encryption key:\n');
+                    console.log(`  ${green(config.encryptionKey)}\n`);
+                    console.log(dim('Use this key in the dashboard "Decrypt Data" button to view your personal data.'));
+                    console.log(dim('Keep it safe — we cannot recover it if lost.\n'));
+                }
+                else {
+                    console.log(yellow('\nNo encryption key configured. Run `npx @rulecatch/ai-pooler init` to set one up.\n'));
+                }
+                break;
+            }
+            if (changed) {
+                fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+                console.log(green('\n+ Config updated.\n'));
+            }
+            else {
+                console.log('\nCurrent config:\n');
+                console.log(`  API key:     ${config.apiKey?.slice(0, 8)}...`);
+                console.log(`  Region:      ${config.region === 'eu' ? 'EU (Frankfurt)' : 'US (Virginia)'}`);
+                console.log(`  Batch size:  ${config.batchSize || 20}`);
+                console.log(`  Encrypted:   ${config.encryptionKey ? 'Yes' : 'No'}`);
+                console.log(dim('\nOverrides:'));
+                console.log(dim('  --batch-size=30'));
+                console.log(dim('  --region=eu'));
+                console.log(dim('  --show-key        Show your encryption key\n'));
+            }
+            break;
+        }
+        case 'backpressure':
+        case 'bp': {
+            console.log('\nBackpressure Status\n');
+            const state = loadState();
+            // Overall health
+            const isHealthy = state.consecutiveFailures === 0 && state.backoffLevel === 0;
+            if (isHealthy) {
+                console.log(`Status:           ${green('Healthy')}`);
+            }
+            else if (state.consecutiveFailures >= 10) {
+                console.log(`Status:           ${red('Circuit Breaker OPEN')}`);
+            }
+            else if (state.backoffLevel >= 5) {
+                console.log(`Status:           ${red('High Backoff')}`);
+            }
+            else {
+                console.log(`Status:           ${yellow('Backing Off')}`);
+            }
+            // Failure info
+            console.log(`\nFailures:         ${state.consecutiveFailures} consecutive`);
+            console.log(`Backoff level:    ${state.backoffLevel}/10`);
+            // Timing
+            if (state.nextAttemptAfter > Date.now()) {
+                const waitSec = Math.ceil((state.nextAttemptAfter - Date.now()) / 1000);
+                console.log(`Next attempt in:  ${waitSec}s`);
+            }
+            else {
+                console.log(`Next attempt:     ${green('Ready now')}`);
+            }
+            if (state.lastSuccessTime > 0) {
+                const ago = Math.floor((Date.now() - state.lastSuccessTime) / 1000);
+                if (ago < 60) {
+                    console.log(`Last success:     ${ago}s ago`);
+                }
+                else if (ago < 3600) {
+                    console.log(`Last success:     ${Math.floor(ago / 60)}m ago`);
+                }
+                else {
+                    console.log(`Last success:     ${Math.floor(ago / 3600)}h ago`);
+                }
+            }
+            else {
+                console.log(`Last success:     ${dim('Never')}`);
+            }
+            // Buffer
+            console.log(`\nPending events:   ${state.pendingEventCount}`);
+            // Last known server capacity
+            if (state.lastCapacity) {
+                console.log(`\nLast Server Response:`);
+                console.log(`  Ready:          ${state.lastCapacity.ready ? green('Yes') : red('No')}`);
+                console.log(`  Max batch:      ${state.lastCapacity.maxBatchSize}`);
+                console.log(`  Delay between:  ${state.lastCapacity.delayBetweenBatches}ms`);
+                if (state.lastCapacity.loadPercent !== undefined) {
+                    const loadColor = state.lastCapacity.loadPercent > 80 ? red :
+                        state.lastCapacity.loadPercent > 50 ? yellow : green;
+                    console.log(`  Server load:    ${loadColor(state.lastCapacity.loadPercent + '%')}`);
+                }
+                if (state.lastCapacity.message) {
+                    console.log(`  Message:        ${dim(state.lastCapacity.message)}`);
+                }
+            }
+            // Reset option
+            const flags = parseArgs();
+            if (flags.reset === 'true') {
+                if (fs.existsSync(BACKPRESSURE_STATE_FILE)) {
+                    fs.unlinkSync(BACKPRESSURE_STATE_FILE);
+                }
+                console.log(green('\n+ Backpressure state reset.\n'));
+            }
+            else if (state.consecutiveFailures > 0 || state.backoffLevel > 0) {
+                console.log(dim('\nTo reset: npx @rulecatch/ai-pooler backpressure --reset=true'));
+            }
+            console.log('');
+            break;
+        }
+        case 'reactivate': {
+            console.log('\nChecking subscription status...\n');
+            // Check if configured
+            if (!fs.existsSync(CONFIG_PATH)) {
+                console.log(red('Not configured. Run `npx @rulecatch/ai-pooler init` first.\n'));
+                process.exit(1);
+            }
+            // Read config for region
+            let config;
+            try {
+                config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            }
+            catch {
+                console.log(red('Failed to read config. Run `npx @rulecatch/ai-pooler init` to reconfigure.\n'));
+                process.exit(1);
+            }
+            if (!config.apiKey) {
+                console.log(red('No API key configured. Run `npx @rulecatch/ai-pooler init` first.\n'));
+                process.exit(1);
+            }
+            // Remove paused file to allow session token request
+            if (fs.existsSync(PAUSED_FILE)) {
+                fs.unlinkSync(PAUSED_FILE);
+            }
+            // Remove old session file to force re-auth
+            if (fs.existsSync(SESSION_FILE)) {
+                fs.unlinkSync(SESSION_FILE);
+            }
+            // Try to acquire a session token to check subscription
+            const region = config.region || 'us';
+            const baseUrl = region === 'eu'
+                ? 'https://api-eu.rulecatch.ai'
+                : 'https://api.rulecatch.ai';
+            try {
+                const response = await fetch(`${baseUrl}/api/v1/ai/pooler/session`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${config.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        projectId: 'reactivate-check',
+                        region,
+                        encrypted: true,
+                    }),
+                });
+                if (response.ok) {
+                    // Subscription is active!
+                    console.log(green('✓ Subscription active!'));
+                    console.log('\nData collection has been reactivated.');
+                    console.log('Events will be sent on your next Claude Code session.\n');
+                    process.exit(0);
+                }
+                // Check for paused response
+                if (response.status === 403) {
+                    const errorBody = await response.json();
+                    if (errorBody.status === 'paused') {
+                        // Write paused file again
+                        fs.writeFileSync(PAUSED_FILE, JSON.stringify({
+                            reason: errorBody.reason,
+                            message: errorBody.message,
+                            region,
+                            dashboardUrl: `https://dashboard${region === 'eu' ? '-eu' : ''}.rulecatch.ai`,
+                            billingUrl: errorBody.billingUrl,
+                            pausedAt: new Date().toISOString(),
+                        }, null, 2), { mode: 0o600 });
+                        console.log(red('✗ Subscription still inactive.\n'));
+                        console.log('╔═══════════════════════════════════════════════════════════════╗');
+                        console.log('║                  SUBSCRIPTION REQUIRED                         ║');
+                        console.log('╠═══════════════════════════════════════════════════════════════╣');
+                        console.log('║                                                               ║');
+                        console.log(`║   ${errorBody.message || 'Your subscription has expired.'}`.padEnd(64) + '║');
+                        console.log('║                                                               ║');
+                        console.log('║   To reactivate data collection:                              ║');
+                        console.log('║                                                               ║');
+                        console.log('║   1. Visit your billing page:                                 ║');
+                        console.log(`║      ${errorBody.billingUrl || `https://dashboard${region === 'eu' ? '-eu' : ''}.rulecatch.ai/billing`}`.padEnd(60) + '║');
+                        console.log('║                                                               ║');
+                        console.log('║   2. Subscribe or update your payment method                  ║');
+                        console.log('║                                                               ║');
+                        console.log('║   3. Return here and run:                                     ║');
+                        console.log('║      npx @rulecatch/ai-pooler reactivate                      ║');
+                        console.log('║                                                               ║');
+                        console.log('╚═══════════════════════════════════════════════════════════════╝');
+                        console.log('');
+                        process.exit(1);
+                    }
+                }
+                // Other error
+                console.log(red(`✗ Failed to check subscription (${response.status})`));
+                console.log('Please try again or contact support.\n');
+                process.exit(1);
+            }
+            catch (err) {
+                console.log(red('✗ Network error'));
+                console.log(`Could not connect to ${baseUrl}`);
+                console.log('Please check your internet connection and try again.\n');
+                process.exit(1);
+            }
+            break;
+        }
+        case 'monitor':
+        case 'live': {
+            // Live monitoring view — watches buffer + flush log in real-time
+            // Debug levels: (none) = compact, -v = verbose (paths), -vv/--debug = full JSON
+            if (!fs.existsSync(CONFIG_PATH)) {
+                console.log(red('Not configured. Run `npx @rulecatch/ai-pooler init` first.\n'));
+                process.exit(1);
+            }
+            const verboseCount = args.filter(a => a === '-v').length + (args.includes('--verbose') ? 1 : 0);
+            const debugMode = args.includes('-vv') || args.includes('--debug') || verboseCount >= 2;
+            const verboseMode = debugMode || verboseCount >= 1;
+            const monConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            const monEndpoint = monConfig.endpoint || (monConfig.region === 'eu' ? 'https://api-eu.rulecatch.ai' : 'https://api.rulecatch.ai');
+            // Derive encryption key once for decrypting buffer events
+            let decryptKey = null;
+            if (monConfig.encryptionKey) {
+                try {
+                    decryptKey = pbkdf2Sync(monConfig.encryptionKey, 'rulecatch', 100000, 32, 'sha256');
+                }
+                catch { /* no decryption available */ }
+            }
+            // Decrypt a hook-encrypted field (format: iv_base64:ciphertext+tag_base64)
+            const decryptHookField = (encrypted) => {
+                if (!decryptKey || !encrypted || !encrypted.includes(':'))
+                    return '';
+                try {
+                    const [ivB64, ctB64] = encrypted.split(':');
+                    const iv = Buffer.from(ivB64, 'base64');
+                    const ctWithTag = Buffer.from(ctB64, 'base64');
+                    const tag = ctWithTag.subarray(ctWithTag.length - 16);
+                    const ciphertext = ctWithTag.subarray(0, ctWithTag.length - 16);
+                    const decipher = createDecipheriv('aes-256-gcm', decryptKey, iv);
+                    decipher.setAuthTag(tag);
+                    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8');
+                }
+                catch {
+                    return '';
+                }
+            };
+            // Cache decrypted cwd per session (populated from session_start events)
+            const cwdCache = new Map();
+            const getCwd = (evt) => {
+                const sessionId = evt.sessionId;
+                if (sessionId && cwdCache.has(sessionId))
+                    return cwdCache.get(sessionId);
+                // Try plaintext first (privacy disabled)
+                let cwd = evt.cwd || '';
+                // Try decrypting (privacy enabled)
+                if (!cwd) {
+                    const encrypted = evt.cwdEncrypted || '';
+                    if (encrypted)
+                        cwd = decryptHookField(encrypted);
+                }
+                if (cwd && sessionId)
+                    cwdCache.set(sessionId, cwd);
+                return cwd;
+            };
+            const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+            const magenta = (s) => `\x1b[35m${s}\x1b[0m`;
+            const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+            const blue = (s) => `\x1b[34m${s}\x1b[0m`;
+            // Check API connectivity + fetch plan/usage info
+            let apiStatus = yellow('⚠️  API not running');
+            let planInfo = '';
+            let usageInfo = '';
+            let modelInfo = '';
+            try {
+                const res = await fetch(`${monEndpoint}/api/v1/ai/validate-key`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${monConfig.apiKey}` },
+                    body: JSON.stringify({ apiKey: monConfig.apiKey }),
+                    signal: AbortSignal.timeout(3000),
+                });
+                if (res.ok) {
+                    apiStatus = green('✅ connected');
+                    const data = await res.json();
+                    // Plan info
+                    const plan = (data.planId || 'starter').charAt(0).toUpperCase() + (data.planId || 'starter').slice(1);
+                    const status = data.subscriptionStatus || '';
+                    const trialDays = data.trialDaysLeft;
+                    if (status === 'trialing' && trialDays !== undefined) {
+                        planInfo = `${cyan(plan)} ${yellow(`(trial: ${trialDays}d left)`)}`;
+                    }
+                    else {
+                        planInfo = `${cyan(plan)} ${dim(`(${status})`)}`;
+                    }
+                    // Token usage
+                    const usage = data.tokenUsage;
+                    if (usage) {
+                        const tokens = usage.totalTokens > 1000000 ? `${(usage.totalTokens / 1000000).toFixed(1)}M` : usage.totalTokens > 1000 ? `${(usage.totalTokens / 1000).toFixed(1)}K` : `${usage.totalTokens}`;
+                        usageInfo = `${tokens} tokens  ${green(`$${usage.totalCost.toFixed(2)}`)}  ${dim(`${usage.sessions} sessions`)}`;
+                    }
+                    // Model
+                    const model = data.model;
+                    if (model) {
+                        // Pretty-print model name: "claude-opus-4-6" → "Claude Opus 4.6"
+                        const pretty = model.replace('claude-', '').replace(/-(\d+)-(\d+)/, ' $1.$2').replace(/\b\w/g, c => c.toUpperCase());
+                        modelInfo = magenta(pretty);
+                    }
+                }
+                else if (res.status === 401) {
+                    console.log(red('\n  ✗ Invalid API key. Run `npx @rulecatch/ai-pooler init` to reconfigure.\n'));
+                    process.exit(1);
+                }
+                else {
+                    apiStatus = yellow(`⚠️  ${res.status}`);
+                }
+            }
+            catch {
+                apiStatus = yellow('⚠️  API not running — will show events locally');
+            }
+            // Print header box
+            const BOX_W = 62;
+            const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+            // Count visible terminal columns (emojis are 2 wide)
+            const visibleWidth = (s) => {
+                const plain = stripAnsi(s);
+                let w = 0;
+                for (const ch of plain) {
+                    w += ch.charCodeAt(0) > 0xFF ? 2 : 1;
+                }
+                return w;
+            };
+            const boxLine = (content) => {
+                const w = visibleWidth(content);
+                const pad = Math.max(0, BOX_W - w);
+                return ` │${content}${' '.repeat(pad)}│`;
+            };
+            const hLine = dim('─'.repeat(BOX_W));
+            console.log('');
+            console.log(` ┌${hLine}┐`);
+            console.log(boxLine(` ${bold('RuleCatch.AI Monitor')}`));
+            console.log(` ├${hLine}┤`);
+            console.log(boxLine(` API:     ${monEndpoint}  ${apiStatus}`));
+            console.log(boxLine(` Key:     ${dim(monConfig.apiKey?.slice(0, 12) + '...')}`));
+            console.log(boxLine(` Project: ${cyan(monConfig.projectId || '(not set)')}`));
+            console.log(boxLine(` Region:  ${monConfig.region === 'eu' ? 'EU' : 'US'}`));
+            if (planInfo)
+                console.log(boxLine(` Plan:    ${planInfo}`));
+            if (modelInfo)
+                console.log(boxLine(` Model:   ${modelInfo}`));
+            if (usageInfo)
+                console.log(boxLine(` Usage:   ${usageInfo}`));
+            console.log(boxLine(` Buffer:  ${getBufferCount()} events pending`));
+            console.log(boxLine(` Level:   ${debugMode ? magenta('debug (full JSON)') : verboseMode ? cyan('verbose (file paths)') : dim('compact')}`));
+            console.log(` └${hLine}┘`);
+            console.log('');
+            console.log(` ${dim('Watching for events... (Ctrl+C to stop)')}`);
+            if (!verboseMode)
+                console.log(` ${dim('Tip: use -v for file paths, -vv for full event JSON')}`);
+            console.log('');
+            // Running session counters (start from server totals, increment locally)
+            const serverUsage = { totalTokens: 0, totalCost: 0, sessions: 0 };
+            try {
+                const res2 = await fetch(`${monEndpoint}/api/v1/ai/validate-key`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${monConfig.apiKey}` },
+                    body: JSON.stringify({ apiKey: monConfig.apiKey }),
+                    signal: AbortSignal.timeout(3000),
+                });
+                if (res2.ok) {
+                    const d2 = await res2.json();
+                    const u = d2.tokenUsage;
+                    if (u) {
+                        serverUsage.totalTokens = u.totalTokens;
+                        serverUsage.totalCost = u.totalCost;
+                        serverUsage.sessions = u.sessions;
+                    }
+                }
+            }
+            catch { /* use zeros */ }
+            let runningTokens = serverUsage.totalTokens;
+            let runningCost = serverUsage.totalCost;
+            const runningModel = modelInfo || dim('unknown');
+            const fmtRunning = () => {
+                const tk = runningTokens > 1000000 ? `${(runningTokens / 1000000).toFixed(1)}M` : runningTokens > 1000 ? `${(runningTokens / 1000).toFixed(1)}K` : `${runningTokens}`;
+                return dim(`[${runningModel} │ ${tk} tk │ $${runningCost.toFixed(2)}]`);
+            };
+            // Track seen files so we don't double-print
+            const seenFiles = new Set();
+            // Preload existing buffer files as "seen" + pre-scan for session_start cwds
+            if (fs.existsSync(BUFFER_DIR)) {
+                for (const f of fs.readdirSync(BUFFER_DIR)) {
+                    seenFiles.add(f);
+                    // Pre-populate cwd cache from existing session_start events
+                    if (f.endsWith('.json')) {
+                        try {
+                            const content = fs.readFileSync(path.join(BUFFER_DIR, f), 'utf-8');
+                            const evt = JSON.parse(content);
+                            if (evt.type === 'session_start')
+                                getCwd(evt);
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+            }
+            let lastBufferCount = getBufferCount();
+            // Format a timestamp
+            const fmtTime = (ts) => {
+                try {
+                    const d = new Date(ts);
+                    return dim(d.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' }));
+                }
+                catch {
+                    return dim('--:--:--');
+                }
+            };
+            // Format a tool call event
+            const fmtEvent = (evt) => {
+                const time = fmtTime(evt.timestamp);
+                const type = evt.type;
+                // Increment running counters from event data
+                const evtInputTk = evt.toolInputSize || 0;
+                const evtOutputTk = evt.toolOutputSize || 0;
+                if (type === 'tool_call') {
+                    runningTokens += evtInputTk + evtOutputTk;
+                    // Estimate cost from model pricing (per token)
+                    const m = (evt.model || '').toLowerCase();
+                    let inRate = 0.000003;
+                    let outRate = 0.000015; // default sonnet
+                    if (m.includes('opus')) {
+                        inRate = 0.000015;
+                        outRate = 0.000075;
+                    }
+                    else if (m.includes('haiku')) {
+                        inRate = 0.00000025;
+                        outRate = 0.00000125;
+                    }
+                    runningCost += (evtInputTk * inRate) + (evtOutputTk * outRate);
+                }
+                if (type === 'session_end') {
+                    const endCost = evt.estimatedCost || 0;
+                    const endTokens = (evt.inputTokens || 0) + (evt.outputTokens || 0);
+                    runningCost += endCost;
+                    runningTokens += endTokens;
+                }
+                const stats = fmtRunning();
+                if (type === 'tool_call') {
+                    const tool = evt.toolName || '?';
+                    const ok = evt.toolSuccess ? green('✓') : red('✗');
+                    const fp = evt.filePath || '';
+                    const op = evt.fileOperation ? dim(`(${evt.fileOperation})`) : '';
+                    const inputSize = evt.toolInputSize ? dim(`${evt.toolInputSize}b`) : '';
+                    const outputSize = evt.toolOutputSize ? dim(`→ ${evt.toolOutputSize}b`) : '';
+                    if (debugMode) {
+                        // Full JSON dump
+                        console.log(` ${time}  ${ok} ${cyan(tool)} ${op} ${stats}`);
+                        const display = { ...evt };
+                        delete display.type;
+                        delete display.timestamp;
+                        delete display.toolName;
+                        console.log(dim(`         ${JSON.stringify(display, null, 2).split('\n').join('\n         ')}`));
+                    }
+                    else if (verboseMode) {
+                        // Full file path, git context, input+output sizes, line changes
+                        const repo = evt.gitRepo ? blue(evt.gitRepo) : '';
+                        const branch = evt.gitBranch ? dim(`(${evt.gitBranch})`) : '';
+                        const lang = evt.language ? dim(`[${evt.language}]`) : '';
+                        const la = evt.linesAdded || 0;
+                        const lr = evt.linesRemoved || 0;
+                        const lineInfo = (la > 0 || lr > 0) ? ` ${green(`+${la}`)}/${red(`-${lr}`)}` : '';
+                        console.log(` ${time}  ${ok} ${cyan(tool.padEnd(12))} ${op} ${inputSize} ${outputSize} ${lang}${lineInfo}  ${stats}`);
+                        if (fp)
+                            console.log(`         ${dim('path:')} ${fp}`);
+                        const evtCwd = getCwd(evt);
+                        if (evtCwd) {
+                            let projLine = `         ${dim('project:')} ${blue(evtCwd)}`;
+                            if (repo) {
+                                projLine += `  ${dim('repo:')} ${repo} ${branch}`;
+                            }
+                            else if (evt.gitBranch || evt.gitCommit) {
+                                const gb = evt.gitBranch ? cyan(evt.gitBranch) : '';
+                                const gc = evt.gitCommit ? dim(evt.gitCommit) : '';
+                                const gd = evt.gitDirty ? yellow('*') : '';
+                                projLine += `  ${gb} ${gc}${gd}`;
+                            }
+                            console.log(projLine);
+                        }
+                    }
+                    else {
+                        // Compact (current default)
+                        const shortPath = fp ? fp.split('/').slice(-2).join('/') : '';
+                        console.log(` ${time}  ${ok} ${cyan(tool.padEnd(8))} ${shortPath} ${op} ${inputSize}  ${stats}`);
+                    }
+                }
+                else if (type === 'session_start') {
+                    const evtCwd = getCwd(evt);
+                    console.log(` ${time}  ${green('▶')} ${bold('Session started')}  ${stats}`);
+                    if (evtCwd) {
+                        let projLine = `         ${dim('project:')} ${blue(evtCwd)}`;
+                        const gitRepo = evt.gitRepo;
+                        if (gitRepo) {
+                            const gitBranch = evt.gitBranch ? dim(`(${evt.gitBranch})`) : '';
+                            projLine += `  ${dim('repo:')} ${blue(gitRepo)} ${gitBranch}`;
+                        }
+                        else if (evt.gitBranch || evt.gitCommit) {
+                            const gb = evt.gitBranch ? cyan(evt.gitBranch) : '';
+                            const gc = evt.gitCommit ? dim(evt.gitCommit) : '';
+                            const gd = evt.gitDirty ? yellow('*') : '';
+                            projLine += `  ${gb} ${gc}${gd}`;
+                        }
+                        console.log(projLine);
+                    }
+                    if (verboseMode) {
+                        const model = evt.model;
+                        const account = evt.account;
+                        if (model)
+                            console.log(`         ${dim('model:')} ${model}`);
+                        if (account)
+                            console.log(`         ${dim('account:')} ${account}`);
+                    }
+                    if (debugMode) {
+                        console.log(dim(`         ${JSON.stringify(evt, null, 2).split('\n').join('\n         ')}`));
+                    }
+                }
+                else if (type === 'session_end') {
+                    console.log(` ${time}  ${red('■')} ${bold('Session ended')}  ${stats}`);
+                    if (verboseMode) {
+                        const cost = evt.estimatedCost;
+                        const tokens = (evt.inputTokens || 0) + (evt.outputTokens || 0);
+                        if (cost)
+                            console.log(`         ${dim('cost:')} ${yellow(`$${cost.toFixed(4)}`)}`);
+                        if (tokens)
+                            console.log(`         ${dim('tokens:')} ${tokens.toLocaleString()}`);
+                    }
+                    if (debugMode) {
+                        console.log(dim(`         ${JSON.stringify(evt, null, 2).split('\n').join('\n         ')}`));
+                    }
+                }
+                else if (type === 'turn_complete') {
+                    console.log(` ${time}  ${dim('↩')} ${dim('Turn complete')}`);
+                }
+                else {
+                    console.log(` ${time}  ${dim('·')} ${dim(type)}`);
+                    if (debugMode) {
+                        console.log(dim(`         ${JSON.stringify(evt, null, 2).split('\n').join('\n         ')}`));
+                    }
+                }
+            };
+            // Watch flush log for activity
+            let lastFlushSize = 0;
+            const flushLog = path.join(RULECATCH_DIR, 'flush.log');
+            if (fs.existsSync(flushLog)) {
+                lastFlushSize = fs.statSync(flushLog).size;
+            }
+            const checkFlushLog = () => {
+                if (!fs.existsSync(flushLog))
+                    return;
+                const stat = fs.statSync(flushLog);
+                if (stat.size > lastFlushSize) {
+                    // Read new lines
+                    const fd = fs.openSync(flushLog, 'r');
+                    const newBytes = Buffer.alloc(stat.size - lastFlushSize);
+                    fs.readSync(fd, newBytes, 0, newBytes.length, lastFlushSize);
+                    fs.closeSync(fd);
+                    const newLines = newBytes.toString().trim().split('\n').filter(Boolean);
+                    for (const line of newLines) {
+                        // Parse flush log entries
+                        if (line.includes('Flushed') || line.includes('flushed')) {
+                            console.log(` ${dim(new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' }))}  ${green('↑')} ${green(line.replace(/^\[.*?\]\s*/, ''))}`);
+                        }
+                        else if (line.includes('Error') || line.includes('error') || line.includes('fail')) {
+                            console.log(` ${dim(new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' }))}  ${red('✗')} ${red(line.replace(/^\[.*?\]\s*/, ''))}`);
+                        }
+                    }
+                    lastFlushSize = stat.size;
+                }
+            };
+            // Watch buffer directory for new files
+            if (!fs.existsSync(BUFFER_DIR)) {
+                fs.mkdirSync(BUFFER_DIR, { recursive: true });
+            }
+            const watcher = fs.watch(BUFFER_DIR, (eventType, filename) => {
+                if (!filename || !filename.endsWith('.json'))
+                    return;
+                if (eventType === 'rename') {
+                    const filepath = path.join(BUFFER_DIR, filename);
+                    // New file appeared
+                    if (!seenFiles.has(filename) && fs.existsSync(filepath)) {
+                        seenFiles.add(filename);
+                        try {
+                            const content = fs.readFileSync(filepath, 'utf-8');
+                            const evt = JSON.parse(content);
+                            fmtEvent(evt);
+                        }
+                        catch { /* file might be mid-write */ }
+                    }
+                    // File removed (flushed)
+                    if (seenFiles.has(filename) && !fs.existsSync(filepath)) {
+                        seenFiles.delete(filename);
+                    }
+                }
+                // Update buffer count periodically
+                const newCount = getBufferCount();
+                if (newCount !== lastBufferCount) {
+                    if (newCount < lastBufferCount) {
+                        const flushed = lastBufferCount - newCount;
+                        console.log(` ${dim(new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' }))}  ${green('↑')} ${green(`Flushed ${flushed} events`)} ${dim(`(${newCount} remaining)`)}`);
+                    }
+                    lastBufferCount = newCount;
+                }
+            });
+            // Periodic checks
+            const interval = setInterval(() => {
+                checkFlushLog();
+            }, 2000);
+            // Handle Ctrl+C gracefully
+            process.on('SIGINT', () => {
+                watcher.close();
+                clearInterval(interval);
+                console.log(`\n ${dim('Monitor stopped.')}\n`);
+                process.exit(0);
+            });
+            // Keep the process alive
+            await new Promise(() => { });
+            break;
+        }
+        case 'help':
+        case '--help':
+        case '-h': {
+            console.log(`
+Rulecatch AI Pooler - Development Analytics (Zero Token Overhead)
+
+Usage:
+  npx @rulecatch/ai-pooler [command] [options]
+
+Commands:
+  init         Interactive setup (API key, encryption, hooks)
+  uninstall    Remove all Rulecatch files and hooks
+  status       Check setup, buffer count, session token
+  flush        Force send all buffered events
+  logs         Show flush activity logs
+  config       View or update configuration
+  monitor      Live event stream — watch events + flushes in real-time (alias: live)
+  backpressure Show detailed backpressure/throttling status (alias: bp)
+  reactivate   Resume data collection after subscription renewal
+
+Init Options:
+  --api-key=KEY        Your Rulecatch API key (starts with dc_)
+  --region=us|eu       Override region (normally auto-detected)
+  --encryption-key=PWD Your encryption password (min 8 chars)
+  --batch-size=20      Events before auto-flush
+
+Config Options:
+  --batch-size=30      Change batch threshold
+  --region=us|eu       Change data region
+
+Log Options:
+  --lines=50           Number of log lines to show
+  --source=hook        Show hook log instead of flush log
+
+Backpressure Options:
+  --reset=true         Reset backpressure state (clears backoff)
+
+Data Flow (Zero Token Overhead):
+  Hook fires -> writes JSON to ~/.claude/rulecatch/buffer/
+  Flush script -> encrypts PII -> sends batch to API
+
+Quick Start:
+  npx @rulecatch/ai-pooler init
+  # Follow interactive prompts, then restart Claude Code
+
+Documentation: https://rulecatch.ai/docs
+`);
+            break;
+        }
+        default: {
+            if (command) {
+                console.log(red(`\nUnknown command: ${command}`));
+            }
+            console.log('Run `npx @rulecatch/ai-pooler help` for usage.\n');
+        }
+    }
+}
+main().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map