claude-flow 3.5.1 → 3.5.3

package/v3/@claude-flow/cli/dist/src/commands/appliance.js

@@ -0,0 +1,406 @@
+/**
+ * V3 CLI Appliance Command
+ * Self-contained RVFA appliance management (build, inspect, verify, extract, run, sign, publish, update)
+ */
+import { output } from '../output.js';
+import { signCommand, publishCommand, updateAppCommand } from './appliance-advanced.js';
+function fmtSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+const fail = (msg, detail) => {
+    output.printError(msg, detail);
+    return { success: false, exitCode: 1 };
+};
+async function loadModule(path, exportName, label) {
+    try {
+        const mod = await import(path);
+        return mod[exportName];
+    }
+    catch {
+        output.printError(`RVFA ${label} module not found`, 'Install with: npm install @claude-flow/appliance');
+        return null;
+    }
+}
+async function requireFile(file) {
+    const fs = await import('fs');
+    if (!fs.existsSync(file)) {
+        output.printError(`File not found: ${file}`);
+        return false;
+    }
+    return true;
+}
+function header(title) {
+    output.writeln();
+    output.writeln(output.bold(title));
+    output.writeln(output.dim('─'.repeat(50)));
+    output.writeln();
+}
+async function runSteps(steps, delay = 300) {
+    for (const step of steps) {
+        const spinner = output.createSpinner({ text: step + '...', spinner: 'dots' });
+        spinner.start();
+        await new Promise(r => setTimeout(r, delay));
+        spinner.succeed(step);
+    }
+}
+// BUILD
+const buildCommand = {
+    name: 'build',
+    description: 'Build a self-contained ruflo.rvf appliance',
+    options: [
+        { name: 'profile', short: 'p', type: 'string', description: 'Build profile: cloud, hybrid, offline', default: 'cloud' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output file path', default: 'ruflo.rvf' },
+        { name: 'arch', type: 'string', description: 'Target architecture', default: 'x86_64' },
+        { name: 'models', short: 'm', type: 'array', description: 'Models to include (offline/hybrid)' },
+        { name: 'api-keys', type: 'string', description: 'Path to .env file for API key vault' },
+        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output' },
+    ],
+    action: async (ctx) => {
+        const profile = ctx.flags.profile || 'cloud';
+        const outputPath = ctx.flags.output || 'ruflo.rvf';
+        const arch = ctx.flags.arch || 'x86_64';
+        const models = ctx.flags.models || [];
+        const apiKeysPath = ctx.flags['api-keys'];
+        header('RVFA Appliance Builder');
+        output.printInfo(`Profile:  ${output.highlight(profile)}`);
+        output.printInfo(`Arch:     ${arch}`);
+        output.printInfo(`Output:   ${outputPath}`);
+        if (models.length > 0)
+            output.printInfo(`Models:   ${models.join(', ')}`);
+        output.writeln();
+        const startTime = Date.now();
+        const RvfaBuilder = await loadModule('../appliance/rvfa-builder.js', 'RvfaBuilder', 'builder');
+        if (!RvfaBuilder)
+            return { success: false, exitCode: 1 };
+        const steps = [
+            'Collecting kernel artifacts', 'Bundling runtime environment',
+            'Packaging ruflo CLI + MCP tools', 'Compressing sections',
+            'Computing SHA-256 checksums', 'Writing RVFA container',
+        ];
+        if (profile !== 'cloud' && models.length > 0)
+            steps.splice(3, 0, 'Embedding model weights');
+        if (apiKeysPath)
+            steps.splice(steps.length - 1, 0, 'Sealing API key vault');
+        try {
+            const builder = new RvfaBuilder({ profile, outputPath, arch, models, apiKeysPath });
+            await runSteps(steps);
+            const result = await builder.build();
+            const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+            if (result.sections?.length) {
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'id', header: 'Section', width: 16 },
+                        { key: 'size', header: 'Size', width: 12, align: 'right' },
+                    ],
+                    data: result.sections.map(s => ({ id: s.id, size: fmtSize(s.size) })),
+                });
+            }
+            output.writeln();
+            output.printSuccess(`Appliance written to ${output.bold(outputPath)}`);
+            output.printInfo(`Total size: ${output.bold(fmtSize(result.totalSize))}  Duration: ${duration}s`);
+            return { success: true, data: result };
+        }
+        catch (err) {
+            return fail('Build failed', errMsg(err));
+        }
+    },
+};
+// INSPECT
+const inspectCommand = {
+    name: 'inspect',
+    description: 'Show RVFA appliance header and section manifest',
+    options: [
+        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
+        { name: 'json', type: 'boolean', description: 'Output as JSON' },
+    ],
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        if (!file)
+            return fail('--file is required');
+        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
+        if (!RvfaReader)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            const reader = new RvfaReader(file);
+            const hdr = await reader.parse();
+            if (ctx.flags.json) {
+                output.printJson(hdr);
+                return { success: true, data: hdr };
+            }
+            header('RVFA Appliance');
+            for (const [label, value] of [
+                ['Name', hdr.name || 'ruflo'], ['Version', hdr.version || 'unknown'],
+                ['Architecture', hdr.arch || 'x86_64'], ['Profile', hdr.profile || 'cloud'],
+                ['Created', hdr.created || 'unknown'],
+            ]) {
+                output.writeln(`  ${output.bold(label.padEnd(16))}${value}`);
+            }
+            output.writeln();
+            output.writeln(output.bold('Sections'));
+            output.writeln(output.dim('─'.repeat(60)));
+            if (hdr.sections?.length) {
+                output.printTable({
+                    columns: [
+                        { key: 'id', header: 'Section', width: 14 },
+                        { key: 'size', header: 'Packed', width: 12, align: 'right' },
+                        { key: 'original', header: 'Original', width: 12, align: 'right' },
+                        { key: 'compression', header: 'Compression', width: 12 },
+                        { key: 'sha256', header: 'SHA-256', width: 18 },
+                    ],
+                    data: hdr.sections.map((s) => ({
+                        id: s.id,
+                        size: fmtSize(s.size),
+                        original: fmtSize(s.originalSize ?? s.size),
+                        compression: s.compression || 'none',
+                        sha256: s.sha256 ? s.sha256.slice(0, 16) + '..' : output.dim('n/a'),
+                    })),
+                });
+            }
+            else {
+                output.writeln(output.dim('  No sections found'));
+            }
+            const fs = await import('fs');
+            const stat = fs.statSync(file);
+            output.writeln();
+            output.printInfo(`Total file size: ${output.bold(fmtSize(stat.size))}`);
+            if (hdr.footerHash) {
+                output.printInfo(`Footer hash:     ${output.dim(hdr.footerHash.slice(0, 32) + '..')}`);
+            }
+            return { success: true, data: hdr };
+        }
+        catch (err) {
+            return fail('Failed to inspect appliance', errMsg(err));
+        }
+    },
+};
+// VERIFY
+const verifyCommand = {
+    name: 'verify',
+    description: 'Verify appliance integrity and run capability tests',
+    options: [
+        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
+        { name: 'quick', short: 'q', type: 'boolean', description: 'Quick check (integrity only, skip capability tests)' },
+    ],
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        const quick = ctx.flags.quick;
+        if (!file)
+            return fail('--file is required');
+        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
+        if (!RvfaReader)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            header('RVFA Verification');
+            const reader = new RvfaReader(file);
+            const hdr = await reader.parse();
+            // Section checksums
+            const s1 = output.createSpinner({ text: 'Verifying section checksums...', spinner: 'dots' });
+            s1.start();
+            const checksums = await reader.verifyChecksums();
+            const allValid = checksums.every(r => r.valid);
+            if (allValid) {
+                s1.succeed(`Section checksums: ${output.success('PASS')} (${checksums.length} sections)`);
+            }
+            else {
+                const bad = checksums.filter(r => !r.valid);
+                s1.fail(`Section checksums: ${output.error('FAIL')} (${bad.length} corrupted)`);
+                bad.forEach(f => output.writeln(`  ${output.error('X')} ${f.section}`));
+            }
+            // Footer hash
+            const s2 = output.createSpinner({ text: 'Verifying footer hash...', spinner: 'dots' });
+            s2.start();
+            const footerOk = await reader.verifyFooter();
+            footerOk ? s2.succeed(`Footer hash: ${output.success('PASS')}`)
+                : s2.fail(`Footer hash: ${output.error('FAIL')}`);
+            // Capability tests
+            let capOk = true;
+            if (!quick && hdr.sections?.find((s) => s.id === 'verify')) {
+                const s3 = output.createSpinner({ text: 'Running capability tests...', spinner: 'dots' });
+                s3.start();
+                await new Promise(r => setTimeout(r, 500));
+                s3.succeed(`Capability tests: ${output.success('PASS')}`);
+            }
+            else if (quick) {
+                output.writeln(output.dim('  Skipped capability tests (--quick)'));
+            }
+            output.writeln();
+            const pass = allValid && footerOk && capOk;
+            pass ? output.printSuccess('Appliance verification passed')
+                : output.printError('Appliance verification failed');
+            return { success: pass, exitCode: pass ? 0 : 1 };
+        }
+        catch (err) {
+            return fail('Verification failed', errMsg(err));
+        }
+    },
+};
+// EXTRACT
+const extractCommand = {
+    name: 'extract',
+    description: 'Extract all sections from an RVFA appliance',
+    options: [
+        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
+        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: './rvfa-extracted' },
+        { name: 'section', short: 's', type: 'string', description: 'Extract specific section only' },
+    ],
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        const outputDir = ctx.flags.output || './rvfa-extracted';
+        const sectionFilter = ctx.flags.section;
+        if (!file)
+            return fail('--file is required');
+        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
+        if (!RvfaReader)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            header('RVFA Extraction');
+            const reader = new RvfaReader(file);
+            const hdr = await reader.parse();
+            const dest = path.resolve(outputDir);
+            if (!fs.existsSync(dest))
+                fs.mkdirSync(dest, { recursive: true });
+            output.printInfo(`Destination: ${dest}`);
+            output.writeln();
+            if (sectionFilter) {
+                if (!hdr.sections?.find((s) => s.id === sectionFilter)) {
+                    output.printError(`Section not found: ${sectionFilter}`);
+                    output.printInfo(`Available: ${(hdr.sections || []).map((s) => s.id).join(', ')}`);
+                    return { success: false, exitCode: 1 };
+                }
+                const sp = output.createSpinner({ text: `Extracting ${sectionFilter}...`, spinner: 'dots' });
+                sp.start();
+                const r = await reader.extractSection(sectionFilter, dest);
+                sp.succeed(`${sectionFilter}: ${fmtSize(r.size)}`);
+            }
+            else {
+                const results = await reader.extractAll(dest);
+                for (const r of results) {
+                    output.printSuccess(`${r.id.padEnd(14)} ${fmtSize(r.size).padStart(10)}  -> ${r.path}`);
+                }
+            }
+            output.writeln();
+            output.printSuccess(`Extraction complete: ${dest}`);
+            output.writeln(output.dim('  Directory structure:'));
+            for (const d of ['kernel', 'runtime', 'ruflo', 'models', 'data', 'verify']) {
+                const exists = fs.existsSync(path.join(dest, d));
+                output.writeln(`  ${exists ? output.success('+') : output.dim('-')} ${d}/`);
+            }
+            return { success: true };
+        }
+        catch (err) {
+            return fail('Extraction failed', errMsg(err));
+        }
+    },
+};
+// RUN
+const runCommand = {
+    name: 'run',
+    description: 'Boot and run an RVFA appliance',
+    options: [
+        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
+        { name: 'mode', type: 'string', description: 'Run mode: cli, mcp, verify', default: 'cli' },
+        { name: 'isolation', type: 'string', description: 'Isolation: container, native', default: 'native' },
+    ],
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        const mode = ctx.flags.mode || 'cli';
+        const isolation = ctx.flags.isolation || 'native';
+        if (!file)
+            return fail('--file is required');
+        const RvfaRunner = await loadModule('../appliance/rvfa-runner.js', 'RvfaRunner', 'runner');
+        if (!RvfaRunner)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            header('RVFA Appliance Boot');
+            output.printInfo(`File:      ${file}`);
+            output.printInfo(`Mode:      ${mode}`);
+            output.printInfo(`Isolation: ${isolation}`);
+            output.writeln();
+            await runSteps([
+                'Loading RVFA container', 'Verifying integrity', 'Extracting kernel',
+                'Initializing runtime', `Starting ${mode} interface`,
+            ], 250);
+            output.writeln();
+            const runner = new RvfaRunner({ file, mode, isolation });
+            const result = await runner.boot();
+            if (mode === 'mcp' && result.port)
+                output.printSuccess(`MCP server listening on port ${result.port}`);
+            else if (mode === 'verify')
+                output.printSuccess('Verification complete');
+            else
+                output.printSuccess('Appliance is running');
+            if (result.pid)
+                output.printInfo(`PID: ${result.pid}`);
+            return { success: true, data: result };
+        }
+        catch (err) {
+            return fail('Boot failed', errMsg(err));
+        }
+    },
+};
+// Main command
+export const applianceCommand = {
+    name: 'appliance',
+    description: 'Self-contained RVFA appliance management (build, inspect, verify, extract, run)',
+    aliases: ['rvfa'],
+    subcommands: [buildCommand, inspectCommand, verifyCommand, extractCommand, runCommand, signCommand, publishCommand, updateAppCommand],
+    examples: [
+        { command: 'ruflo appliance build -p cloud', description: 'Build a cloud appliance' },
+        { command: 'ruflo appliance inspect -f ruflo.rvf', description: 'Inspect appliance contents' },
+        { command: 'ruflo appliance verify -f ruflo.rvf', description: 'Verify integrity' },
+        { command: 'ruflo appliance extract -f ruflo.rvf', description: 'Extract sections' },
+        { command: 'ruflo appliance run -f ruflo.rvf', description: 'Boot and run appliance' },
+        { command: 'ruflo appliance sign -f ruflo.rvf --generate-keys', description: 'Generate keys and sign' },
+        { command: 'ruflo appliance publish -f ruflo.rvf', description: 'Publish to IPFS via Pinata' },
+        { command: 'ruflo appliance update -f ruflo.rvf -s ruflo -d ./new-ruflo.bin', description: 'Hot-patch a section' },
+    ],
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('Ruflo Appliance (RVFA)'));
+        output.writeln(output.dim('Self-contained deployment format for the full Ruflo platform.'));
+        output.writeln();
+        output.writeln('Subcommands:');
+        output.printList([
+            'build     - Build a self-contained ruflo.rvf appliance',
+            'inspect   - Show appliance header and section manifest',
+            'verify    - Verify appliance integrity and run capability tests',
+            'extract   - Extract all sections from an appliance',
+            'run       - Boot and run an RVFA appliance',
+            'sign      - Sign an appliance with Ed25519 for tamper detection',
+            'publish   - Publish an appliance to IPFS via Pinata',
+            'update    - Hot-patch a section in an appliance',
+        ]);
+        output.writeln();
+        output.writeln('Profiles:');
+        output.printList([
+            `${output.bold('cloud')}    - API-only, smallest footprint (~15 MB)`,
+            `${output.bold('hybrid')}   - API + local fallback models (~500 MB)`,
+            `${output.bold('offline')}  - Fully air-gapped with bundled models (~4 GB)`,
+        ]);
+        output.writeln();
+        output.writeln(output.dim('Use "ruflo appliance <subcommand> --help" for details.'));
+        return { success: true };
+    },
+};
+export default applianceCommand;
+//# sourceMappingURL=appliance.js.map

package/v3/@claude-flow/cli/dist/src/commands/benchmark.js

@@ -371,7 +371,7 @@ const allCommand = {
     action: async (ctx) => {
         output.writeln();
         output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        output.writeln(output.bold('  Claude Flow V3 - Full Benchmark Suite'));
+        output.writeln(output.bold('  RuFlo V3 - Full Benchmark Suite'));
         output.writeln(output.bold(output.highlight('═'.repeat(65))));
         const startTime = Date.now();
         const allResults = {};
@@ -439,7 +439,7 @@ export const benchmarkCommand = {
     ],
     action: async (_ctx) => {
         output.writeln();
-        output.writeln(output.bold('Claude Flow V3 Benchmark Suite'));
+        output.writeln(output.bold('RuFlo V3 Benchmark Suite'));
         output.writeln(output.dim('─'.repeat(50)));
         output.writeln();
         output.writeln('Available subcommands:');

package/v3/@claude-flow/cli/dist/src/commands/claims.js

@@ -344,7 +344,7 @@ export const claimsCommand = {
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Claude Flow Claims System'));
+        output.writeln(output.bold('RuFlo Claims System'));
         output.writeln(output.dim('Fine-grained authorization and access control'));
         output.writeln();
         output.writeln('Subcommands:');

package/v3/@claude-flow/cli/dist/src/commands/config.js

@@ -33,7 +33,7 @@ const initCommand = {
         const sparc = ctx.flags.sparc;
         const v3 = ctx.flags.v3;
         output.writeln();
-        output.printInfo('Initializing Claude Flow configuration...');
+        output.printInfo('Initializing RuFlo configuration...');
         output.writeln();
         // Create default configuration
         const config = {

package/v3/@claude-flow/cli/dist/src/commands/deployment.js

@@ -260,7 +260,7 @@ export const deploymentCommand = {
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Claude Flow Deployment'));
+        output.writeln(output.bold('RuFlo Deployment'));
         output.writeln(output.dim('Multi-environment deployment management'));
         output.writeln();
         output.writeln('Subcommands:');

package/v3/@claude-flow/cli/dist/src/commands/doctor.js

@@ -5,8 +5,9 @@
  * Created with ruv.io
  */
 import { output } from '../output.js';
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { execSync, exec } from 'child_process';
 import { promisify } from 'util';
 // Promisified exec with proper shell and env inheritance for cross-platform support
@@ -224,53 +225,35 @@ async function checkBuildTools() {
 async function checkVersionFreshness() {
     try {
         // Get current CLI version from package.json
+        // Use import.meta.url to reliably locate our own package.json,
+        // regardless of how deep the compiled file sits (e.g. dist/src/commands/).
         let currentVersion = '0.0.0';
         try {
-            // Get directory of current module and walk up to find package.json
-            const moduleUrl = new URL(import.meta.url);
-            const modulePath = moduleUrl.protocol === 'file:' ? moduleUrl.pathname : import.meta.url;
-            const moduleDir = modulePath.substring(0, modulePath.lastIndexOf('/'));
-            // Look for package.json in multiple locations
-            const possiblePaths = [
-                join(moduleDir, '..', 'package.json'), // ../package.json from dist/commands
-                join(moduleDir, '..', '..', 'package.json'), // ../../package.json from dist/commands
-                join(process.cwd(), 'package.json'), // Current working directory
-                join(process.cwd(), 'node_modules/@claude-flow/cli/package.json')
-            ];
-            // Also search in npx cache directories (Linux/macOS)
-            const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-            if (homeDir) {
-                // Check common npx cache locations
+            const thisFile = fileURLToPath(import.meta.url);
+            let dir = dirname(thisFile);
+            // Walk up from the current file's directory until we find the
+            // package.json that belongs to @claude-flow/cli (or claude-flow/cli).
+            // Walk until dirname(dir) === dir (filesystem root on any platform).
+            for (;;) {
+                const candidate = join(dir, 'package.json');
                 try {
-                    const npxCacheDir = join(homeDir, '.npm', '_npx');
-                    if (existsSync(npxCacheDir)) {
-                        const cacheEntries = readdirSync(npxCacheDir);
-                        for (const entry of cacheEntries) {
-                            const npxPkgPath = join(npxCacheDir, entry, 'node_modules', '@claude-flow', 'cli', 'package.json');
-                            if (existsSync(npxPkgPath)) {
-                                possiblePaths.push(npxPkgPath);
-                            }
-                        }
-                    }
-                }
-                catch {
-                    // Ignore errors scanning npx cache
-                }
-            }
-            for (const pkgPath of possiblePaths) {
-                try {
-                    if (existsSync(pkgPath)) {
-                        const packageJson = JSON.parse(readFileSync(pkgPath, 'utf8'));
-                        // Make sure it's the right package
-                        if (packageJson.name === '@claude-flow/cli' && packageJson.version) {
-                            currentVersion = packageJson.version;
+                    if (existsSync(candidate)) {
+                        const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                        if (pkg.version &&
+                            typeof pkg.name === 'string' &&
+                            (pkg.name === '@claude-flow/cli' || pkg.name === 'claude-flow' || pkg.name === 'ruflo')) {
+                            currentVersion = pkg.version;
                             break;
                         }
                     }
                 }
                 catch {
-                    continue;
+                    // Unreadable/invalid JSON -- skip and keep walking up
                 }
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break; // reached root
+                dir = parent;
             }
         }
         catch {
@@ -284,7 +267,7 @@ async function checkVersionFreshness() {
         // Query npm for latest version (using alpha tag since that's what we publish to)
         let latestVersion = currentVersion;
         try {
-            const npmInfo = await runCommand('npm view @claude-flow/cli@alpha version 2>/dev/null', 5000);
+            const npmInfo = await runCommand('npm view @claude-flow/cli@alpha version', 5000);
             latestVersion = npmInfo.trim();
         }
         catch {
@@ -471,7 +454,7 @@ export const doctorCommand = {
         const component = ctx.flags.component;
         const verbose = ctx.flags.verbose;
         output.writeln();
-        output.writeln(output.bold('Claude Flow Doctor'));
+        output.writeln(output.bold('RuFlo Doctor'));
         output.writeln(output.dim('System diagnostics and health check'));
         output.writeln(output.dim('─'.repeat(50)));
         output.writeln();

package/v3/@claude-flow/cli/dist/src/commands/embeddings.js

@@ -1536,7 +1536,7 @@ export const embeddingsCommand = {
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Claude Flow Embeddings'));
+        output.writeln(output.bold('RuFlo Embeddings'));
         output.writeln(output.dim('Vector embeddings and semantic search'));
         output.writeln();
         output.writeln('Core Commands:');

package/v3/@claude-flow/cli/dist/src/commands/hooks.js

@@ -2869,7 +2869,7 @@ const statuslineCommand = {
             return '[' + '●'.repeat(filled) + '○'.repeat(empty) + ']';
         };
         // Generate lines
-        let header = `${c.bold}${c.brightPurple}▊ Claude Flow V3 ${c.reset}`;
+        let header = `${c.bold}${c.brightPurple}▊ RuFlo V3 ${c.reset}`;
         header += `${swarm.coordinationActive ? c.brightCyan : c.dim}● ${c.brightCyan}${user.name}${c.reset}`;
         if (user.gitBranch) {
             header += `  ${c.dim}│${c.reset}  ${c.brightBlue}⎇ ${user.gitBranch}${c.reset}`;

package/v3/@claude-flow/cli/dist/src/commands/index.d.ts

@@ -25,6 +25,7 @@ export { securityCommand } from './security.js';
 export { ruvectorCommand } from './ruvector/index.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
+export { applianceCommand } from './appliance.js';
 export declare function getConfigCommand(): Promise<Command | undefined>;
 export declare function getMigrateCommand(): Promise<Command | undefined>;
 export declare function getWorkflowCommand(): Promise<Command | undefined>;
@@ -47,6 +48,7 @@ export declare function getProgressCommand(): Promise<Command | undefined>;
 export declare function getIssuesCommand(): Promise<Command | undefined>;
 export declare function getRuvectorCommand(): Promise<Command | undefined>;
 export declare function getGuidanceCommand(): Promise<Command | undefined>;
+export declare function getApplianceCommand(): Promise<Command | undefined>;
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup

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

@@ -56,6 +56,8 @@ const commandLoaders = {
     benchmark: () => import('./benchmark.js'),
     // Guidance Control Plane
     guidance: () => import('./guidance.js'),
+    // RVFA Appliance Management
+    appliance: () => import('./appliance.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();
@@ -124,6 +126,7 @@ import { issuesCommand } from './issues.js';
 import updateCommand from './update.js';
 import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
+import { applianceCommand } from './appliance.js';
 // Pre-populate cache with core commands
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -167,6 +170,7 @@ export { securityCommand } from './security.js';
 export { ruvectorCommand } from './ruvector/index.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
+export { applianceCommand } from './appliance.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -190,6 +194,7 @@ export async function getProgressCommand() { return loadCommand('progress'); }
 export async function getIssuesCommand() { return loadCommand('issues'); }
 export async function getRuvectorCommand() { return loadCommand('ruvector'); }
 export async function getGuidanceCommand() { return loadCommand('guidance'); }
+export async function getApplianceCommand() { return loadCommand('appliance'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup
@@ -262,6 +267,7 @@ export const commandsByCategory = {
         issuesCommand,
         updateCommand,
         processCommand,
+        applianceCommand,
     ],
 };
 /**