agentic-flow 3.0.0-alpha.1 → 3.0.0

package/dist/cli-proxy.js

@@ -3,29 +3,15 @@
  * Agentic Flow - Standalone CLI with integrated OpenRouter proxy
  * Usage: npx agentic-flow-proxy --agent coder --task "Create code" --openrouter
  */
-import dotenv from "dotenv";
-import { existsSync, readFileSync } from 'fs';
+// Must stay the first import: loads cwd/.env (or --env-file <path>), never a
+// parent directory, and never endpoint overrides from an implicit .env.
+import "./utils/load-env.js";
+import { readFileSync } from 'fs';
 import { resolve as pathResolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
-// Load .env from current directory, or search up the directory tree
-function loadEnvRecursive(startPath = process.cwd()) {
-    let currentPath = startPath;
-    const root = pathResolve('/');
-    while (currentPath !== root) {
-        const envPath = pathResolve(currentPath, '.env');
-        if (existsSync(envPath)) {
-            dotenv.config({ path: envPath });
-            return true;
-        }
-        currentPath = pathResolve(currentPath, '..');
-    }
-    // Fallback to default behavior
-    dotenv.config();
-    return false;
-}
-loadEnvRecursive();
 import { AnthropicToOpenRouterProxy } from "./proxy/anthropic-to-openrouter.js";
 import { AnthropicToRequestyProxy } from "./proxy/anthropic-to-requesty.js";
+import { proxyClientBaseUrl } from "./proxy/proxy-auth.js";
 import { logger } from "./utils/logger.js";
 import { parseArgs } from "./utils/cli.js";
 import { getAgent, listAgents } from "./utils/agentLoader.js";
@@ -34,6 +20,7 @@ import { handleReasoningBankCommand } from "./utils/reasoningbankCommands.js";
 import { handleConfigCommand } from "./cli/config-wizard.js";
 import { handleAgentCommand } from "./cli/agent-manager.js";
 import { handleFederationCommand } from "./cli/federation-cli.js";
+import { handleInitCommand } from "./cli/commands/init.js";
 import { ModelOptimizer } from "./utils/modelOptimizer.js";
 import { detectModelCapabilities } from "./utils/modelCapabilities.js";
 import { AgentBoosterPreprocessor } from "./utils/agentBoosterPreprocessor.js";
@@ -43,7 +30,7 @@ const packageJson = JSON.parse(readFileSync(pathResolve(__dirname, '../package.j
 const VERSION = packageJson.version;
 class AgenticFlowCLI {
     proxyServer = null;
-    proxyPort = 3000;
+    proxyPort = parseInt(process.env.PROXY_PORT || '3000', 10);
     async start() {
         const options = parseArgs();
         if (options.version) {
@@ -55,10 +42,16 @@ class AgenticFlowCLI {
             process.exit(0);
         }
         // If no mode and no agent specified, show help
-        if (!options.agent && options.mode !== 'list' && !['config', 'agent-manager', 'mcp-manager', 'proxy', 'quic', 'claude-code', 'mcp', 'reasoningbank', 'federation', 'daemon', 'hive-mind', 'hivemind', 'hooks', 'session', 'swarm', 'memory', 'task', 'doctor', 'autopilot'].includes(options.mode)) {
+        if (!options.agent && options.mode !== 'list' && !['init', 'config', 'agent-manager', 'mcp-manager', 'proxy', 'quic', 'claude-code', 'mcp', 'reasoningbank', 'federation', 'hooks', 'workers', 'embeddings'].includes(options.mode)) {
             this.printHelp();
             process.exit(0);
         }
+        if (options.mode === 'init') {
+            // Handle init command - creates .claude/ folder and configuration
+            const initArgs = process.argv.slice(3); // Skip 'node', 'cli-proxy.js', 'init'
+            await handleInitCommand(initArgs);
+            process.exit(0);
+        }
         if (options.mode === 'list') {
             this.listAgents();
             process.exit(0);
@@ -151,49 +144,50 @@ class AgenticFlowCLI {
             await handleFederationCommand(federationArgs);
             process.exit(0);
         }
-        if (options.mode === 'daemon') {
-            const { handleDaemonCommand } = await import('./cli/daemon-cli.js');
-            await handleDaemonCommand(process.argv.slice(3));
-            process.exit(0);
-        }
-        if (options.mode === 'hive-mind' || options.mode === 'hivemind') {
-            const { handleHiveMindCommand } = await import('./cli/hivemind-cli.js');
-            await handleHiveMindCommand(process.argv.slice(3));
-            process.exit(0);
-        }
         if (options.mode === 'hooks') {
-            const { handleHooksCommand } = await import('./cli/hooks-cli.js');
-            await handleHooksCommand(process.argv.slice(3));
-            process.exit(0);
-        }
-        if (options.mode === 'session') {
-            const { handleSessionCommand } = await import('./cli/session-cli.js');
-            await handleSessionCommand(process.argv.slice(3));
-            process.exit(0);
-        }
-        if (options.mode === 'swarm') {
-            const { handleSwarmCommand } = await import('./cli/swarm-cli.js');
-            await handleSwarmCommand(process.argv.slice(3));
-            process.exit(0);
-        }
-        if (options.mode === 'memory') {
-            const { handleMemoryCommand } = await import('./cli/memory-cli.js');
-            await handleMemoryCommand(process.argv.slice(3));
-            process.exit(0);
-        }
-        if (options.mode === 'task') {
-            const { handleTaskCommand } = await import('./cli/task-cli.js');
-            await handleTaskCommand(process.argv.slice(3));
-            process.exit(0);
+            // Handle Hooks commands (intelligence, init, pre-edit, post-edit, etc.)
+            const { spawn } = await import('child_process');
+            const { resolve, dirname } = await import('path');
+            const { fileURLToPath } = await import('url');
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const hooksPath = resolve(__dirname, './cli/commands/hooks.js');
+            // Pass all args after 'hooks' to hooks command
+            const hooksArgs = process.argv.slice(3);
+            const proc = spawn('node', [hooksPath, ...hooksArgs], {
+                stdio: 'inherit'
+            });
+            proc.on('exit', (code) => {
+                process.exit(code || 0);
+            });
+            process.on('SIGINT', () => proc.kill('SIGINT'));
+            process.on('SIGTERM', () => proc.kill('SIGTERM'));
+            return;
         }
-        if (options.mode === 'doctor') {
-            const { handleDoctorCommand } = await import('./cli/doctor-cli.js');
-            await handleDoctorCommand(process.argv.slice(3));
-            process.exit(0);
+        if (options.mode === 'workers') {
+            // Handle Workers commands (status, cleanup, dispatch-prompt, etc.)
+            const { spawn } = await import('child_process');
+            const { resolve, dirname } = await import('path');
+            const { fileURLToPath } = await import('url');
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const workersPath = resolve(__dirname, './cli/commands/workers.js');
+            // Pass all args after 'workers' to workers command
+            const workersArgs = process.argv.slice(3);
+            const proc = spawn('node', [workersPath, ...workersArgs], {
+                stdio: 'inherit'
+            });
+            proc.on('exit', (code) => {
+                process.exit(code || 0);
+            });
+            process.on('SIGINT', () => proc.kill('SIGINT'));
+            process.on('SIGTERM', () => proc.kill('SIGTERM'));
+            return;
         }
-        if (options.mode === 'autopilot') {
-            const { handleAutopilotCommand } = await import('./cli/autopilot-cli.js');
-            await handleAutopilotCommand(process.argv.slice(3));
+        if (options.mode === 'embeddings') {
+            // Handle Embeddings commands (init, download, list, benchmark, status)
+            const { handleEmbeddingsCommand } = await import('./cli/commands/embeddings.js');
+            await handleEmbeddingsCommand(process.argv.slice(3));
             process.exit(0);
         }
         // Apply model optimization if requested
@@ -218,6 +212,7 @@ class AgenticFlowCLI {
         }
         // Determine which provider to use
         const useONNX = this.shouldUseONNX(options);
+        const useOllama = this.shouldUseOllama(options);
         const useOpenRouter = this.shouldUseOpenRouter(options);
         const useGemini = this.shouldUseGemini(options);
         // Requesty temporarily disabled - keep proxy files for future use
@@ -246,6 +241,10 @@ class AgenticFlowCLI {
                 console.log('🚀 Initializing Requesty proxy...');
                 await this.startRequestyProxy(options.model);
             }
+            else if (useOllama) {
+                console.log('🚀 Initializing Ollama local proxy...');
+                await this.startOllamaProxy(options.model);
+            }
             else if (useOpenRouter) {
                 console.log('🚀 Initializing OpenRouter proxy...');
                 await this.startOpenRouterProxy(options.model);
@@ -284,6 +283,19 @@ class AgenticFlowCLI {
         }
         return false;
     }
+    shouldUseOllama(options) {
+        // Use Ollama if:
+        // 1. Provider is explicitly set to ollama
+        // 2. PROVIDER env var is set to ollama
+        // 3. USE_OLLAMA env var is set
+        if (options.provider === 'ollama' || process.env.PROVIDER === 'ollama') {
+            return true;
+        }
+        if (process.env.USE_OLLAMA === 'true') {
+            return true;
+        }
+        return false;
+    }
     shouldUseGemini(options) {
         // Use Gemini if:
         // 1. Provider is explicitly set to gemini
@@ -322,6 +334,12 @@ class AgenticFlowCLI {
         return false;
     }
     shouldUseOpenRouter(options) {
+        // Don't use OpenRouter if Ollama is explicitly requested — otherwise a stray
+        // OPENROUTER_API_KEY in the environment captures the run via the key-based
+        // auto-selection below.
+        if (options.provider === 'ollama' || process.env.PROVIDER === 'ollama' || process.env.USE_OLLAMA === 'true') {
+            return false;
+        }
         // Don't use OpenRouter if ONNX, Gemini, or Requesty is explicitly requested
         if (options.provider === 'onnx' || process.env.USE_ONNX === 'true' || process.env.PROVIDER === 'onnx') {
             return false;
@@ -351,6 +369,38 @@ class AgenticFlowCLI {
         }
         return false;
     }
+    async startOllamaProxy(modelOverride) {
+        // Ollama exposes an OpenAI-compatible /v1/chat/completions, which is exactly
+        // what AnthropicToOpenRouterProxy speaks — so this needs no new proxy class.
+        // The key below is a placeholder, not a credential: Ollama ignores
+        // Authorization entirely, and requiring a real one would defeat the point of
+        // a local provider.
+        const host = (process.env.OLLAMA_HOST || 'http://localhost:11434').replace(/\/+$/, '');
+        logger.info('Starting integrated Ollama proxy', { host });
+        const defaultModel = modelOverride ||
+            process.env.OLLAMA_MODEL ||
+            process.env.COMPLETION_MODEL ||
+            'qwen2.5-coder:7b';
+        const capabilities = detectModelCapabilities(defaultModel);
+        const proxy = new AnthropicToOpenRouterProxy({
+            openrouterApiKey: 'ollama-local-placeholder',
+            openrouterBaseUrl: `${host}/v1`,
+            defaultModel,
+            capabilities: capabilities
+        });
+        proxy.start(this.proxyPort);
+        this.proxyServer = proxy;
+        // The proxy only accepts its per-run token. Overwrite rather than fill in:
+        // a real Anthropic key would otherwise be sent to the proxy and rejected.
+        process.env.ANTHROPIC_BASE_URL = proxyClientBaseUrl(this.proxyPort);
+        process.env.ANTHROPIC_API_KEY = proxy.getAuthToken();
+        console.log(`🔗 Proxy Mode: Ollama (local, no API key)`);
+        console.log(`🔧 Proxy URL: ${process.env.ANTHROPIC_BASE_URL}`);
+        console.log(`🔧 Ollama:    ${host}/v1`);
+        console.log(`🤖 Model:     ${defaultModel}\n`);
+        // Wait for proxy to be ready
+        await new Promise(resolve => setTimeout(resolve, 1500));
+    }
     async startOpenRouterProxy(modelOverride) {
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
@@ -373,14 +423,12 @@ class AgenticFlowCLI {
         // Start proxy in background
         proxy.start(this.proxyPort);
         this.proxyServer = proxy;
-        // Set ANTHROPIC_BASE_URL to proxy
-        process.env.ANTHROPIC_BASE_URL = `http://localhost:${this.proxyPort}`;
-        // Set dummy ANTHROPIC_API_KEY for proxy (actual auth uses OPENROUTER_API_KEY)
-        if (!process.env.ANTHROPIC_API_KEY) {
-            process.env.ANTHROPIC_API_KEY = 'sk-ant-proxy-dummy-key';
-        }
+        // The proxy only accepts its per-run token. Overwrite rather than fill in:
+        // a real Anthropic key would otherwise be sent to the proxy and rejected.
+        process.env.ANTHROPIC_BASE_URL = proxyClientBaseUrl(this.proxyPort);
+        process.env.ANTHROPIC_API_KEY = proxy.getAuthToken();
         console.log(`🔗 Proxy Mode: OpenRouter`);
-        console.log(`🔧 Proxy URL: http://localhost:${this.proxyPort}`);
+        console.log(`🔧 Proxy URL: ${process.env.ANTHROPIC_BASE_URL}`);
         console.log(`🤖 Default Model: ${defaultModel}`);
         if (capabilities.requiresEmulation) {
             console.log(`\n⚙️  Detected: Model lacks native tool support`);
@@ -414,14 +462,12 @@ class AgenticFlowCLI {
         // Start proxy in background
         proxy.start(this.proxyPort);
         this.proxyServer = proxy;
-        // Set ANTHROPIC_BASE_URL to proxy
-        process.env.ANTHROPIC_BASE_URL = `http://localhost:${this.proxyPort}`;
-        // Set dummy ANTHROPIC_API_KEY for proxy (actual auth uses GOOGLE_GEMINI_API_KEY)
-        if (!process.env.ANTHROPIC_API_KEY) {
-            process.env.ANTHROPIC_API_KEY = 'sk-ant-proxy-dummy-key';
-        }
+        // The proxy only accepts its per-run token. Overwrite rather than fill in:
+        // a real Anthropic key would otherwise be sent to the proxy and rejected.
+        process.env.ANTHROPIC_BASE_URL = proxyClientBaseUrl(this.proxyPort);
+        process.env.ANTHROPIC_API_KEY = proxy.getAuthToken();
         console.log(`🔗 Proxy Mode: Google Gemini`);
-        console.log(`🔧 Proxy URL: http://localhost:${this.proxyPort}`);
+        console.log(`🔧 Proxy URL: ${process.env.ANTHROPIC_BASE_URL}`);
         console.log(`🤖 Default Model: ${defaultModel}\n`);
         // Wait for proxy to be ready
         await new Promise(resolve => setTimeout(resolve, 1500));
@@ -448,14 +494,12 @@ class AgenticFlowCLI {
         // Start proxy in background
         proxy.start(this.proxyPort);
         this.proxyServer = proxy;
-        // Set ANTHROPIC_BASE_URL to proxy
-        process.env.ANTHROPIC_BASE_URL = `http://localhost:${this.proxyPort}`;
-        // Set dummy ANTHROPIC_API_KEY for proxy (actual auth uses REQUESTY_API_KEY)
-        if (!process.env.ANTHROPIC_API_KEY) {
-            process.env.ANTHROPIC_API_KEY = 'sk-ant-proxy-dummy-key';
-        }
+        // The proxy only accepts its per-run token. Overwrite rather than fill in:
+        // a real Anthropic key would otherwise be sent to the proxy and rejected.
+        process.env.ANTHROPIC_BASE_URL = proxyClientBaseUrl(this.proxyPort);
+        process.env.ANTHROPIC_API_KEY = proxy.getAuthToken();
         console.log(`🔗 Proxy Mode: Requesty`);
-        console.log(`🔧 Proxy URL: http://localhost:${this.proxyPort}`);
+        console.log(`🔧 Proxy URL: ${process.env.ANTHROPIC_BASE_URL}`);
         console.log(`🤖 Default Model: ${defaultModel}`);
         if (capabilities.requiresEmulation) {
             console.log(`\n⚙️  Detected: Model lacks native tool support`);
@@ -483,13 +527,13 @@ class AgenticFlowCLI {
         await proxy.start();
         this.proxyServer = proxy;
         // Set ANTHROPIC_BASE_URL to ONNX proxy
-        process.env.ANTHROPIC_BASE_URL = `http://localhost:${onnxProxyPort}`;
+        process.env.ANTHROPIC_BASE_URL = proxyClientBaseUrl(onnxProxyPort);
         // Set dummy ANTHROPIC_API_KEY for proxy (local inference doesn't need key)
         if (!process.env.ANTHROPIC_API_KEY) {
             process.env.ANTHROPIC_API_KEY = 'sk-ant-onnx-local-key';
         }
         console.log(`🔗 Proxy Mode: ONNX Local Inference`);
-        console.log(`🔧 Proxy URL: http://localhost:${onnxProxyPort}`);
+        console.log(`🔧 Proxy URL: ${process.env.ANTHROPIC_BASE_URL}`);
         console.log(`🤖 Model: Phi-4-mini-instruct (ONNX)\n`);
         // Wait for proxy to be ready and model to load
         console.log('⏳ Loading ONNX model... (this may take a moment)\n');
@@ -546,10 +590,14 @@ Set it with:
             console.log(`✅ Proxy server running!
 
 Configure Claude Code:
-  export ANTHROPIC_BASE_URL=http://localhost:${port}
-  export ANTHROPIC_API_KEY=sk-ant-proxy-dummy-key
+  export ANTHROPIC_BASE_URL=${proxyClientBaseUrl(port)}
+  export ANTHROPIC_API_KEY=${proxy.getAuthToken()}
   claude
 
+The proxy rejects requests without this token. Set AGENTIC_FLOW_PROXY_TOKEN
+to keep the same token across restarts, and AGENTIC_FLOW_PROXY_HOST to bind
+an address other than 127.0.0.1.
+
 Cost Savings: ~85% vs direct Anthropic API
 `);
         }
@@ -574,16 +622,21 @@ Get your key at: https://openrouter.ai/keys
             const { AnthropicToOpenRouterProxy } = await import('./proxy/anthropic-to-openrouter.js');
             const proxy = new AnthropicToOpenRouterProxy({
                 openrouterApiKey: apiKey,
+                openrouterBaseUrl: process.env.ANTHROPIC_PROXY_BASE_URL,
                 defaultModel: finalModel
             });
             proxy.start(port);
             console.log(`✅ Proxy server running!
 
 Configure Claude Code:
-  export ANTHROPIC_BASE_URL=http://localhost:${port}
-  export ANTHROPIC_API_KEY=sk-ant-proxy-dummy-key
+  export ANTHROPIC_BASE_URL=${proxyClientBaseUrl(port)}
+  export ANTHROPIC_API_KEY=${proxy.getAuthToken()}
   claude
 
+The proxy rejects requests without this token. Set AGENTIC_FLOW_PROXY_TOKEN
+to keep the same token across restarts, and AGENTIC_FLOW_PROXY_HOST to bind
+an address other than 127.0.0.1.
+
 Cost Savings: ~90% vs direct Anthropic API
 Popular Models:
   - openai/gpt-4o-mini (fast, cheap)
@@ -620,6 +673,8 @@ ENVIRONMENT VARIABLES:
   GOOGLE_GEMINI_API_KEY       Required for Gemini
   OPENROUTER_API_KEY          Required for OpenRouter
   COMPLETION_MODEL            Default model (optional)
+  AGENTIC_FLOW_PROXY_TOKEN    Token clients must send (default: random per run)
+  AGENTIC_FLOW_PROXY_HOST     Bind address (default: 127.0.0.1)
 
 EXAMPLES:
   # Start Gemini proxy
@@ -628,9 +683,9 @@ EXAMPLES:
   # Start OpenRouter proxy with GPT-4o-mini
   npx agentic-flow proxy --provider openrouter --model "openai/gpt-4o-mini"
 
-  # Use with Claude Code
-  export ANTHROPIC_BASE_URL=http://localhost:3000
-  export ANTHROPIC_API_KEY=sk-ant-proxy-dummy-key
+  # Use with Claude Code (the proxy prints its token on start)
+  export ANTHROPIC_BASE_URL=http://127.0.0.1:3000
+  export ANTHROPIC_API_KEY=<token printed by the proxy>
   claude
 `);
     }
@@ -791,13 +846,15 @@ PERFORMANCE:
         }
         // Check for API key (unless using ONNX)
         const isOnnx = options.provider === 'onnx' || process.env.USE_ONNX === 'true' || process.env.PROVIDER === 'onnx';
-        if (!isOnnx && !useOpenRouter && !useGemini && !useRequesty && !process.env.ANTHROPIC_API_KEY) {
+        const isOllama = options.provider === 'ollama' || process.env.USE_OLLAMA === 'true' || process.env.PROVIDER === 'ollama';
+        if (!isOnnx && !isOllama && !useOpenRouter && !useGemini && !useRequesty && !process.env.ANTHROPIC_API_KEY) {
             console.error('\n❌ Error: ANTHROPIC_API_KEY is required\n');
             console.error('Please set your API key:');
             console.error('  export ANTHROPIC_API_KEY=sk-ant-xxxxx\n');
             console.error('Or use alternative providers:');
             console.error('  --provider openrouter  (requires OPENROUTER_API_KEY)');
             console.error('  --provider gemini      (requires GOOGLE_GEMINI_API_KEY)');
+            console.error('  --provider ollama      (free local inference via Ollama, no key)');
             console.error('  --provider onnx        (free local inference)\n');
             process.exit(1);
         }
@@ -855,6 +912,11 @@ PERFORMANCE:
             console.log(`🔧 Provider: Google Gemini`);
             console.log(`🔧 Model: ${model}\n`);
         }
+        else if (isOllama) {
+            const model = options.model || process.env.OLLAMA_MODEL || process.env.COMPLETION_MODEL || 'qwen2.5-coder:7b';
+            console.log(`🔧 Provider: Ollama (local, no API key)`);
+            console.log(`🔧 Model: ${model}\n`);
+        }
         else if (options.provider === 'onnx' || process.env.USE_ONNX === 'true' || process.env.PROVIDER === 'onnx') {
             console.log(`🔧 Provider: ONNX Local (Phi-4-mini)`);
             console.log(`💾 Free local inference - no API costs`);
@@ -959,6 +1021,7 @@ USAGE:
   npx agentic-flow [COMMAND] [OPTIONS]
 
 COMMANDS:
+  init [options]          Initialize project with .claude/ folder and configuration
   config [subcommand]     Manage environment configuration (interactive wizard)
   mcp <command> [server]  Manage MCP servers (start, stop, status, list)
   agent <command>         Agent management (list, create, info, conflicts)
@@ -1002,10 +1065,44 @@ FEDERATION COMMANDS:
   Federation enables ephemeral agents (5s-15min lifetime) with persistent memory.
   Hub stores memories permanently; agents access past learnings from dead agents.
 
+EMBEDDINGS COMMANDS:
+  npx agentic-flow embeddings init       Download and initialize embeddings (default: all-MiniLM-L6-v2)
+  npx agentic-flow embeddings download   Download a specific model
+  npx agentic-flow embeddings list       List available embedding models
+  npx agentic-flow embeddings benchmark  Run embedding performance benchmarks
+  npx agentic-flow embeddings status     Show embeddings system status
+
+  Optimized ONNX embeddings with LRU cache, SIMD operations, and 150x faster search.
+
+HOOKS COMMANDS:
+  npx agentic-flow hooks                 Show all hook commands
+  npx agentic-flow hooks pre-edit        Get context before editing a file
+  npx agentic-flow hooks post-edit       Record edit outcome for learning
+  npx agentic-flow hooks route           Route task to optimal agent
+  npx agentic-flow hooks pretrain        Analyze repository to bootstrap intelligence
+  npx agentic-flow hooks build-agents    Generate optimized agent configurations
+  npx agentic-flow hooks metrics         View learning metrics dashboard
+  npx agentic-flow hooks intelligence    RuVector intelligence commands (SONA + MoE + HNSW)
+  npx agentic-flow hooks init            Initialize hooks in project
+
+  Self-learning hooks for intelligent agent routing and optimization.
+
+WORKERS COMMANDS:
+  npx agentic-flow workers               Show all worker commands
+  npx agentic-flow workers dispatch      Dispatch background workers from triggers
+  npx agentic-flow workers status        Get worker status
+  npx agentic-flow workers triggers      List available trigger keywords
+  npx agentic-flow workers stats         Get worker statistics
+  npx agentic-flow workers results       View worker analysis results
+  npx agentic-flow workers benchmark     Run worker performance benchmarks
+  npx agentic-flow workers native        Run native ruvector workers
+
+  Background workers for non-blocking analysis tasks.
+
 OPTIONS:
   --task, -t <task>           Task description for agent mode
   --model, -m <model>         Model to use (triggers OpenRouter if contains "/")
-  --provider, -p <name>       Provider to use (anthropic, openrouter, gemini, onnx)
+  --provider, -p <name>       Provider to use (anthropic, openrouter, gemini, onnx, ollama)
   --stream, -s                Enable real-time streaming output
   --help, -h                  Show this help message
 
@@ -1156,9 +1253,8 @@ TWO WAYS TO USE AGENTIC-FLOW:
         npx agentic-flow proxy --provider openrouter
 
       Terminal 2 - Configure Claude Code:
-        export ANTHROPIC_BASE_URL="http://localhost:3000"
-        export ANTHROPIC_API_KEY="sk-ant-proxy-dummy-key"
-        export OPENROUTER_API_KEY="sk-or-v1-xxxxx"
+        export ANTHROPIC_BASE_URL="http://127.0.0.1:3000"
+        export ANTHROPIC_API_KEY="<token printed by the proxy>"
         claude  # Now uses OpenRouter via proxy
 
   Benefits of proxy mode: