claude-flow 3.7.0-alpha.11 → 3.7.0-alpha.13

package/v3/@claude-flow/cli/dist/src/memory/rabitq-index.js

@@ -81,11 +81,11 @@ export async function buildRabitqIndex(options) {
             const SQL = await initSqlJs();
             const fileBuffer = fs.readFileSync(dbPath);
             const db = new SQL.Database(fileBuffer);
-            const result = db.exec(`
-        SELECT id, key, namespace, embedding
-        FROM memory_entries
-        WHERE status = 'active' AND embedding IS NOT NULL
-        LIMIT 50000
+            const result = db.exec(`
+        SELECT id, key, namespace, embedding
+        FROM memory_entries
+        WHERE status = 'active' AND embedding IS NOT NULL
+        LIMIT 50000
       `);
             if (result[0]?.values) {
                 for (const row of result[0].values) {

package/v3/@claude-flow/cli/dist/src/memory/sona-optimizer.js

@@ -137,7 +137,6 @@ export class SONAOptimizer {
         if (this.sonaEngine !== undefined)
             return; // already attempted
         try {
-            // @ts-ignore — optional peer dep; types resolve only when installed.
             const sona = await import('@ruvector/sona');
             const EngineCtor = sona.SonaEngine || sona.default?.SonaEngine;
             if (EngineCtor) {

package/v3/@claude-flow/cli/dist/src/runtime/headless.js

@@ -62,34 +62,34 @@ function parseArgs() {
  * Show help message
  */
 function showHelp() {
-    console.log(`
-Headless Runtime for RuFlo V3
-
-Usage:
-  headless --worker <type>    Run a specific worker
-  headless --daemon           Start background daemon
-  headless --benchmark        Run performance benchmarks
-  headless --status           Show system status
-
-Workers: ${HEADLESS_WORKER_TYPES.join(', ')}
-
-Options:
-  -w, --worker <type>   Worker type to run
-  -d, --daemon          Run as daemon
-  -b, --benchmark       Run benchmarks
-  -s, --status          Show status
-  -t, --timeout <ms>    Execution timeout (default: 60000)
-  -v, --verbose         Verbose output
-  -h, --help            Show help
-
-Environment:
-  CLAUDE_FLOW_HEADLESS=true   Enable headless mode
-  CLAUDE_CODE_HEADLESS=true   Enable Claude Code headless
-
-Examples:
-  headless --worker audit --timeout 120000
-  headless --daemon
-  headless --benchmark
+    console.log(`
+Headless Runtime for RuFlo V3
+
+Usage:
+  headless --worker <type>    Run a specific worker
+  headless --daemon           Start background daemon
+  headless --benchmark        Run performance benchmarks
+  headless --status           Show system status
+
+Workers: ${HEADLESS_WORKER_TYPES.join(', ')}
+
+Options:
+  -w, --worker <type>   Worker type to run
+  -d, --daemon          Run as daemon
+  -b, --benchmark       Run benchmarks
+  -s, --status          Show status
+  -t, --timeout <ms>    Execution timeout (default: 60000)
+  -v, --verbose         Verbose output
+  -h, --help            Show help
+
+Environment:
+  CLAUDE_FLOW_HEADLESS=true   Enable headless mode
+  CLAUDE_CODE_HEADLESS=true   Enable Claude Code headless
+
+Examples:
+  headless --worker audit --timeout 120000
+  headless --daemon
+  headless --benchmark
 `);
 }
 /**

package/v3/@claude-flow/cli/dist/src/services/headless-worker-executor.js

@@ -75,18 +75,18 @@ export const HEADLESS_WORKER_CONFIGS = {
         description: 'AI-powered security analysis',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze this codebase for security vulnerabilities:
-- Check for hardcoded secrets (API keys, passwords)
-- Identify SQL injection risks
-- Find XSS vulnerabilities
-- Check for insecure dependencies
-- Identify authentication/authorization issues
-
-Provide a JSON report with:
-{
-  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
-  "riskScore": 0-100,
-  "recommendations": ["..."]
+            promptTemplate: `Analyze this codebase for security vulnerabilities:
+- Check for hardcoded secrets (API keys, passwords)
+- Identify SQL injection risks
+- Find XSS vulnerabilities
+- Check for insecure dependencies
+- Identify authentication/authorization issues
+
+Provide a JSON report with:
+{
+  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
+  "riskScore": 0-100,
+  "recommendations": ["..."]
 }`,
             sandbox: 'strict',
             model: 'haiku',
@@ -103,13 +103,13 @@ Provide a JSON report with:
         description: 'AI optimization suggestions',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze this codebase for performance optimizations:
-- Identify N+1 query patterns
-- Find unnecessary re-renders in React
-- Suggest caching opportunities
-- Identify memory leaks
-- Find redundant computations
-
+            promptTemplate: `Analyze this codebase for performance optimizations:
+- Identify N+1 query patterns
+- Find unnecessary re-renders in React
+- Suggest caching opportunities
+- Identify memory leaks
+- Find redundant computations
+
 Provide actionable suggestions with code examples.`,
             sandbox: 'permissive',
             model: 'sonnet',
@@ -126,13 +126,13 @@ Provide actionable suggestions with code examples.`,
         description: 'AI test gap analysis',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze test coverage and identify gaps:
-- Find untested functions and classes
-- Identify edge cases not covered
-- Suggest new test scenarios
-- Check for missing error handling tests
-- Identify integration test gaps
-
+            promptTemplate: `Analyze test coverage and identify gaps:
+- Find untested functions and classes
+- Identify edge cases not covered
+- Suggest new test scenarios
+- Check for missing error handling tests
+- Identify integration test gaps
+
 For each gap, provide a test skeleton.`,
             sandbox: 'permissive',
             model: 'sonnet',
@@ -149,13 +149,13 @@ For each gap, provide a test skeleton.`,
         description: 'AI documentation generation',
         enabled: false,
         headless: {
-            promptTemplate: `Generate documentation for undocumented code:
-- Add JSDoc comments to functions
-- Create README sections for modules
-- Document API endpoints
-- Add inline comments for complex logic
-- Generate usage examples
-
+            promptTemplate: `Generate documentation for undocumented code:
+- Add JSDoc comments to functions
+- Create README sections for modules
+- Document API endpoints
+- Add inline comments for complex logic
+- Generate usage examples
+
 Focus on public APIs and exported functions.`,
             sandbox: 'permissive',
             model: 'haiku',
@@ -172,19 +172,19 @@ Focus on public APIs and exported functions.`,
         description: 'Deep knowledge acquisition',
         enabled: false,
         headless: {
-            promptTemplate: `Deeply analyze this codebase to learn:
-- Architectural patterns used
-- Coding conventions
-- Domain-specific terminology
-- Common patterns and idioms
-- Team preferences
-
-Provide insights as JSON:
-{
-  "architecture": { "patterns": [...], "style": "..." },
-  "conventions": { "naming": "...", "formatting": "..." },
-  "domains": ["..."],
-  "insights": ["..."]
+            promptTemplate: `Deeply analyze this codebase to learn:
+- Architectural patterns used
+- Coding conventions
+- Domain-specific terminology
+- Common patterns and idioms
+- Team preferences
+
+Provide insights as JSON:
+{
+  "architecture": { "patterns": [...], "style": "..." },
+  "conventions": { "naming": "...", "formatting": "..." },
+  "domains": ["..."],
+  "insights": ["..."]
 }`,
             sandbox: 'strict',
             model: 'opus',
@@ -201,13 +201,13 @@ Provide insights as JSON:
         description: 'AI refactoring suggestions',
         enabled: false,
         headless: {
-            promptTemplate: `Suggest refactoring opportunities:
-- Identify code duplication
-- Suggest better abstractions
-- Find opportunities for design patterns
-- Identify overly complex functions
-- Suggest module reorganization
-
+            promptTemplate: `Suggest refactoring opportunities:
+- Identify code duplication
+- Suggest better abstractions
+- Find opportunities for design patterns
+- Identify overly complex functions
+- Suggest module reorganization
+
 Provide before/after code examples.`,
             sandbox: 'permissive',
             model: 'sonnet',
@@ -224,13 +224,13 @@ Provide before/after code examples.`,
         description: 'Deep code analysis',
         enabled: false,
         headless: {
-            promptTemplate: `Perform deep analysis of this codebase:
-- Understand data flow
-- Map dependencies
-- Identify architectural issues
-- Find potential bugs
-- Analyze error handling
-
+            promptTemplate: `Perform deep analysis of this codebase:
+- Understand data flow
+- Map dependencies
+- Identify architectural issues
+- Find potential bugs
+- Analyze error handling
+
 Provide comprehensive report.`,
             sandbox: 'strict',
             model: 'opus',
@@ -247,18 +247,18 @@ Provide comprehensive report.`,
         description: 'Predictive preloading',
         enabled: false,
         headless: {
-            promptTemplate: `Based on recent activity, predict what the developer needs:
-- Files likely to be edited next
-- Tests that should be run
-- Documentation to reference
-- Dependencies to check
-
-Provide preload suggestions as JSON:
-{
-  "filesToPreload": ["..."],
-  "testsToRun": ["..."],
-  "docsToReference": ["..."],
-  "confidence": 0.0-1.0
+            promptTemplate: `Based on recent activity, predict what the developer needs:
+- Files likely to be edited next
+- Tests that should be run
+- Documentation to reference
+- Dependencies to check
+
+Provide preload suggestions as JSON:
+{
+  "filesToPreload": ["..."],
+  "testsToRun": ["..."],
+  "docsToReference": ["..."],
+  "confidence": 0.0-1.0
 }`,
             sandbox: 'strict',
             model: 'haiku',
@@ -794,20 +794,20 @@ export class HeadlessWorkerExecutor extends EventEmitter {
      */
     buildPrompt(template, context) {
         if (!context) {
-            return `${template}
-
-## Instructions
-
+            return `${template}
+
+## Instructions
+
 Analyze the codebase and provide your response following the format specified in the task.`;
         }
-        return `${template}
-
-## Codebase Context
-
-${context}
-
-## Instructions
-
+        return `${template}
+
+## Codebase Context
+
+${context}
+
+## Instructions
+
 Analyze the above codebase context and provide your response following the format specified in the task.`;
     }
     /**

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -63,6 +63,7 @@ export declare class WorkerDaemon extends EventEmitter {
     private config;
     private workers;
     private timers;
+    private queuePollTimer?;
     private running;
     private startedAt?;
     private projectRoot;
@@ -94,8 +95,11 @@ export declare class WorkerDaemon extends EventEmitter {
      */
     static getEffectiveCpuCount(): number;
     /**
-     * Read daemon-specific config from .claude-flow/config.json
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
+     * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.
+     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'.
+     * #1844: prefer JSON when both exist (existing behavior) but fall back
+     * to YAML so operators using the v3 canonical YAML format aren't silently
+     * ignored. The chosen path is logged at info level.
      */
     private readDaemonConfigFromFile;
     /**
@@ -138,6 +142,14 @@ export declare class WorkerDaemon extends EventEmitter {
      * Start the daemon and all enabled workers
      */
     start(): Promise<void>;
+    /**
+     * #1845: ingest queue entries written by mcp__hooks_worker-dispatch.
+     * Each entry is a JSON file at `.claude-flow/daemon-queue/<id>.json`
+     * with `{ workerId, trigger, context, enqueuedAt }`. We move processed
+     * files to `.claude-flow/daemon-queue/.processed/` so the daemon never
+     * re-runs the same dispatch and operators can inspect history.
+     */
+    private processDispatchQueue;
     /**
      * Stop the daemon and all workers
      */
@@ -170,6 +182,17 @@ export declare class WorkerDaemon extends EventEmitter {
      * Run the actual worker logic
      */
     private runWorkerLogic;
+    /**
+     * #1793: persist a headless worker result to the same metrics file the
+     * local fallback writes to. Without this, AI-mode workers produced rich
+     * structured output (audit findings, perf signals, test-gap analysis)
+     * that lived only in `.claude-flow/logs/headless/*_result.log` and was
+     * invisible to `npx ruflo memory stats` or the metrics consumers.
+     *
+     * The mapping mirrors the `*Local` worker implementations below so a
+     * single consumer path works regardless of execution mode.
+     */
+    private persistHeadlessResult;
     private runMapWorker;
     /**
      * Local audit worker (fallback when headless unavailable)

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -34,6 +34,9 @@ export class WorkerDaemon extends EventEmitter {
     config;
     workers = new Map();
     timers = new Map();
+    // #1845: separate timer for the MCP-dispatch queue poller. Kept off
+    // the per-worker map so stop() clears both kinds without confusion.
+    queuePollTimer;
     running = false;
     startedAt;
     projectRoot;
@@ -169,22 +172,52 @@ export class WorkerDaemon extends EventEmitter {
         return cpus().length || 1;
     }
     /**
-     * Read daemon-specific config from .claude-flow/config.json
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
+     * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.
+     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'.
+     * #1844: prefer JSON when both exist (existing behavior) but fall back
+     * to YAML so operators using the v3 canonical YAML format aren't silently
+     * ignored. The chosen path is logged at info level.
      */
     readDaemonConfigFromFile(claudeFlowDir) {
-        const configPath = join(claudeFlowDir, 'config.json');
-        if (!existsSync(configPath)) {
-            // Warn if config.yaml exists but config.json does not (#1395 Bug 4)
-            const yamlPath = join(claudeFlowDir, 'config.yaml');
-            const ymlPath = join(claudeFlowDir, 'config.yml');
-            if (existsSync(yamlPath) || existsSync(ymlPath)) {
-                this.log('warn', `Found ${existsSync(yamlPath) ? 'config.yaml' : 'config.yml'} but daemon reads only config.json — YAML config is being ignored. Convert to JSON or create config.json.`);
+        const jsonPath = join(claudeFlowDir, 'config.json');
+        const yamlPath = join(claudeFlowDir, 'config.yaml');
+        const ymlPath = join(claudeFlowDir, 'config.yml');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let raw;
+        let chosenPath;
+        if (existsSync(jsonPath)) {
+            try {
+                raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
+                chosenPath = jsonPath;
+            }
+            catch {
+                return {};
+            }
+        }
+        else if (existsSync(yamlPath) || existsSync(ymlPath)) {
+            const yPath = existsSync(yamlPath) ? yamlPath : ymlPath;
+            try {
+                // Lazy-load yaml so the daemon doesn't hard-require it; if the
+                // dep isn't installed, fall back to the previous warn-only path.
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const yamlMod = require('yaml');
+                const parsed = yamlMod.parse(readFileSync(yPath, 'utf-8'));
+                if (parsed && typeof parsed === 'object') {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    raw = parsed;
+                    chosenPath = yPath;
+                }
             }
+            catch {
+                this.log('warn', `Found ${yPath} but yaml parser unavailable. Install \`yaml\` or convert to JSON. Falling back to defaults.`);
+                return {};
+            }
+        }
+        if (!raw || !chosenPath) {
             return {};
         }
+        this.log('info', `Daemon config loaded from ${chosenPath}`);
         try {
-            const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
             // Support both flat keys at root and nested under scopes.project
             const cfg = raw?.scopes?.project ?? raw;
             const rawCpuLoad = cfg['daemon.resourceThresholds.maxCpuLoad'] ?? raw['daemon.resourceThresholds.maxCpuLoad'];
@@ -401,10 +434,90 @@ export class WorkerDaemon extends EventEmitter {
                 this.scheduleWorker(workerConfig);
             }
         }
+        // #1845: poll the MCP-dispatch queue directory so workers requested
+        // via mcp__hooks_worker-dispatch (in a separate process) actually
+        // execute here. Previously the dispatch wrote to a process-local Map
+        // that the daemon could never see.
+        this.queuePollTimer = setInterval(() => {
+            void this.processDispatchQueue();
+        }, 5_000);
+        if (typeof this.queuePollTimer.unref === 'function') {
+            this.queuePollTimer.unref();
+        }
         // Save state
         this.saveState();
         this.log('info', `Daemon started (PID: ${process.pid}, CPUs: ${cpus().length}, workers: ${this.config.workers.filter(w => w.enabled).length}, maxCpuLoad: ${this.config.resourceThresholds.maxCpuLoad}, minFreeMemoryPercent: ${this.config.resourceThresholds.minFreeMemoryPercent}%)`);
     }
+    /**
+     * #1845: ingest queue entries written by mcp__hooks_worker-dispatch.
+     * Each entry is a JSON file at `.claude-flow/daemon-queue/<id>.json`
+     * with `{ workerId, trigger, context, enqueuedAt }`. We move processed
+     * files to `.claude-flow/daemon-queue/.processed/` so the daemon never
+     * re-runs the same dispatch and operators can inspect history.
+     */
+    async processDispatchQueue() {
+        if (!this.running)
+            return;
+        const queueDir = join(this.projectRoot, '.claude-flow', 'daemon-queue');
+        if (!existsSync(queueDir))
+            return;
+        let entries;
+        try {
+            const fs = await import('fs');
+            entries = fs.readdirSync(queueDir).filter((n) => n.endsWith('.json'));
+        }
+        catch {
+            return;
+        }
+        if (entries.length === 0)
+            return;
+        const fs = await import('fs');
+        const processedDir = join(queueDir, '.processed');
+        if (!existsSync(processedDir)) {
+            try {
+                fs.mkdirSync(processedDir, { recursive: true });
+            }
+            catch { /* race ok */ }
+        }
+        for (const entry of entries) {
+            const src = join(queueDir, entry);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let payload;
+            try {
+                payload = JSON.parse(fs.readFileSync(src, 'utf-8'));
+            }
+            catch {
+                // Malformed entry — quarantine so we don't loop on it
+                try {
+                    fs.renameSync(src, join(processedDir, `bad-${entry}`));
+                }
+                catch { /* nothing more we can do */ }
+                continue;
+            }
+            const trigger = payload?.trigger;
+            const workerId = payload?.workerId;
+            if (!trigger || !this.config.workers.some((w) => w.type === trigger)) {
+                try {
+                    fs.renameSync(src, join(processedDir, `unknown-${entry}`));
+                }
+                catch { /* ok */ }
+                continue;
+            }
+            try {
+                this.log('info', `Dequeued ${trigger}${workerId ? ` (id=${workerId})` : ''} from MCP dispatch queue`);
+                await this.triggerWorker(trigger);
+            }
+            catch (err) {
+                this.log('warn', `Queued worker ${trigger} failed: ${err.message}`);
+            }
+            finally {
+                try {
+                    fs.renameSync(src, join(processedDir, entry));
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
     /**
      * Stop the daemon and all workers
      */
@@ -420,6 +533,11 @@ export class WorkerDaemon extends EventEmitter {
             this.log('info', `Stopped worker: ${type}`);
         }
         this.timers.clear();
+        // #1845: stop the MCP-dispatch queue poller too.
+        if (this.queuePollTimer) {
+            clearInterval(this.queuePollTimer);
+            this.queuePollTimer = undefined;
+        }
         this.running = false;
         this.removePidFile();
         this.saveState();
@@ -607,6 +725,17 @@ export class WorkerDaemon extends EventEmitter {
             try {
                 this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
                 const result = await this.headlessExecutor.execute(workerConfig.type);
+                // #1793: persist the headless result to the same metrics files the
+                // local workers write to. Without this, AI-mode runs produced rich
+                // parsedOutput that lived only in `.claude-flow/logs/headless/*` and
+                // never reached `.claude-flow/metrics/<name>.json` — `memory stats`
+                // and downstream consumers saw nothing despite successful runs.
+                try {
+                    this.persistHeadlessResult(workerConfig.type, result);
+                }
+                catch (persistError) {
+                    this.log('warn', `Failed to persist headless result for ${workerConfig.type}: ${persistError.message}`);
+                }
                 return {
                     mode: 'headless',
                     ...result,
@@ -651,6 +780,53 @@ export class WorkerDaemon extends EventEmitter {
                 return { status: 'unknown worker type', mode: 'local' };
         }
     }
+    /**
+     * #1793: persist a headless worker result to the same metrics file the
+     * local fallback writes to. Without this, AI-mode workers produced rich
+     * structured output (audit findings, perf signals, test-gap analysis)
+     * that lived only in `.claude-flow/logs/headless/*_result.log` and was
+     * invisible to `npx ruflo memory stats` or the metrics consumers.
+     *
+     * The mapping mirrors the `*Local` worker implementations below so a
+     * single consumer path works regardless of execution mode.
+     */
+    persistHeadlessResult(workerType, result) {
+        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+        if (!existsSync(metricsDir))
+            mkdirSync(metricsDir, { recursive: true });
+        // Filename mirrors the local-mode worker writes (security-audit.json,
+        // performance.json, test-gaps.json) so a downstream reader doesn't
+        // care which mode produced the data.
+        const filenameMap = {
+            audit: 'security-audit.json',
+            optimize: 'performance.json',
+            testgaps: 'test-gaps.json',
+            document: 'documentation.json',
+            refactor: 'refactor.json',
+            deepdive: 'deepdive.json',
+            ultralearn: 'ultralearn.json',
+            predict: 'predictions.json',
+        };
+        const filename = filenameMap[workerType] ?? `${workerType}.json`;
+        const metricsFile = join(metricsDir, filename);
+        const persisted = {
+            timestamp: result.timestamp instanceof Date ? result.timestamp.toISOString() : new Date().toISOString(),
+            mode: 'headless',
+            workerType,
+            model: result.model,
+            durationMs: result.durationMs,
+            tokensUsed: result.tokensUsed,
+            executionId: result.executionId,
+            success: result.success,
+            // Structured findings live here when the worker emits JSON (e.g. the
+            // audit worker's vulnerability list). Fall back to a raw-output
+            // pointer so consumers can still locate the full log.
+            findings: result.parsedOutput ?? null,
+            rawOutputPreview: typeof result.output === 'string' ? result.output.slice(0, 2000) : undefined,
+            rawOutputLength: typeof result.output === 'string' ? result.output.length : 0,
+        };
+        writeFileSync(metricsFile, JSON.stringify(persisted, null, 2));
+    }
     // Worker implementations
     async runMapWorker() {
         // Scan project structure and update metrics

package/v3/@claude-flow/cli/dist/src/transfer/deploy-seraphine.js

@@ -71,29 +71,29 @@ function parseArgs() {
  * Print help message
  */
 function printHelp() {
-    console.log(`
-Seraphine Genesis Deployer
-==========================
-
-Deploy the foundational Claude Flow pattern model.
-
-Usage:
-  npx ts-node deploy-seraphine.ts [options]
-
-Options:
-  --output, -o <path>     Output file path
-  --to-ipfs, --ipfs       Upload to IPFS
-  --anonymize, -a <level> Anonymization level (minimal|standard|strict|paranoid)
-  --gateway, -g <url>     IPFS gateway URL
-  --no-pin                Don't pin to pinning service
-  --no-validate           Skip validation
-  --verbose, -v           Verbose output
-  --help, -h              Show this help
-
-Examples:
-  npx ts-node deploy-seraphine.ts --output ./seraphine-genesis.cfp.json
-  npx ts-node deploy-seraphine.ts --to-ipfs --anonymize strict
-  npx ts-node deploy-seraphine.ts --to-ipfs --gateway https://dweb.link
+    console.log(`
+Seraphine Genesis Deployer
+==========================
+
+Deploy the foundational Claude Flow pattern model.
+
+Usage:
+  npx ts-node deploy-seraphine.ts [options]
+
+Options:
+  --output, -o <path>     Output file path
+  --to-ipfs, --ipfs       Upload to IPFS
+  --anonymize, -a <level> Anonymization level (minimal|standard|strict|paranoid)
+  --gateway, -g <url>     IPFS gateway URL
+  --no-pin                Don't pin to pinning service
+  --no-validate           Skip validation
+  --verbose, -v           Verbose output
+  --help, -h              Show this help
+
+Examples:
+  npx ts-node deploy-seraphine.ts --output ./seraphine-genesis.cfp.json
+  npx ts-node deploy-seraphine.ts --to-ipfs --anonymize strict
+  npx ts-node deploy-seraphine.ts --to-ipfs --gateway https://dweb.link
 `);
 }
 /**