odd-flow 1.0.0 → 1.2.0

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/commands/embeddings.js

@@ -14,7 +14,7 @@ import { output } from '../output.js';
 // Dynamic imports for embeddings package
 async function getEmbeddings() {
     try {
-        return await import('@claude-flow/embeddings');
+        return await import('@odd-flow/embeddings');
     }
     catch {
         return null;
@@ -31,8 +31,8 @@ const generateCommand = {
         { name: 'output', short: 'o', type: 'string', description: 'Output format: json, array, preview', default: 'preview' },
     ],
     examples: [
-        { command: 'claude-flow embeddings generate -t "Hello world"', description: 'Generate embedding' },
-        { command: 'claude-flow embeddings generate -t "Test" -o json', description: 'Output as JSON' },
+        { command: 'odd-flow embeddings generate -t "Hello world"', description: 'Generate embedding' },
+        { command: 'odd-flow embeddings generate -t "Test" -o json', description: 'Output as JSON' },
     ],
     action: async (ctx) => {
         const text = ctx.flags.text;
@@ -103,8 +103,8 @@ const searchCommand = {
         { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
     ],
     examples: [
-        { command: 'claude-flow embeddings search -q "error handling"', description: 'Search for similar' },
-        { command: 'claude-flow embeddings search -q "test" -l 5', description: 'Limit results' },
+        { command: 'odd-flow embeddings search -q "error handling"', description: 'Search for similar' },
+        { command: 'odd-flow embeddings search -q "test" -l 5', description: 'Limit results' },
     ],
     action: async (ctx) => {
         const query = ctx.flags.query;
@@ -129,7 +129,7 @@ const searchCommand = {
             if (!fs.existsSync(fullDbPath)) {
                 spinner.fail('Database not found');
                 output.printWarning(`No database at ${fullDbPath}`);
-                output.printInfo('Run: claude-flow memory init');
+                output.printInfo('Run: odd-flow memory init');
                 return { success: false, exitCode: 1 };
             }
             // Load sql.js
@@ -211,7 +211,7 @@ const searchCommand = {
             if (topResults.length === 0) {
                 output.writeln();
                 output.printWarning('No matches found');
-                output.printInfo(`Try: claude-flow memory store -k "key" --value "your data"`);
+                output.printInfo(`Try: odd-flow memory store -k "key" --value "your data"`);
                 return { success: true, data: [] };
             }
             output.writeln();
@@ -269,7 +269,7 @@ const compareCommand = {
         { name: 'metric', short: 'm', type: 'string', description: 'Metric: cosine, euclidean, dot', default: 'cosine' },
     ],
     examples: [
-        { command: 'claude-flow embeddings compare --text1 "Hello" --text2 "Hi there"', description: 'Compare texts' },
+        { command: 'odd-flow embeddings compare --text1 "Hello" --text2 "Hi there"', description: 'Compare texts' },
     ],
     action: async (ctx) => {
         const text1 = ctx.flags.text1;
@@ -354,8 +354,8 @@ const collectionsCommand = {
         { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
     ],
     examples: [
-        { command: 'claude-flow embeddings collections', description: 'List collections' },
-        { command: 'claude-flow embeddings collections -a stats', description: 'Show detailed stats' },
+        { command: 'odd-flow embeddings collections', description: 'List collections' },
+        { command: 'odd-flow embeddings collections -a stats', description: 'Show detailed stats' },
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
@@ -370,7 +370,7 @@ const collectionsCommand = {
             // Check if database exists
             if (!fs.existsSync(fullDbPath)) {
                 output.printWarning('No database found');
-                output.printInfo('Run: claude-flow memory init');
+                output.printInfo('Run: odd-flow memory init');
                 output.writeln();
                 output.writeln(output.dim('No collections yet - initialize memory first'));
                 return { success: true, data: [] };
@@ -414,7 +414,7 @@ const collectionsCommand = {
                 output.printWarning('No collections found');
                 output.writeln();
                 output.writeln(output.dim('Store some data first:'));
-                output.writeln(output.highlight('  claude-flow memory store -k "key" --value "data"'));
+                output.writeln(output.highlight('  odd-flow memory store -k "key" --value "data"'));
                 return { success: true, data: [] };
             }
             output.printTable({
@@ -458,9 +458,9 @@ const indexCommand = {
         { name: 'm', type: 'number', description: 'HNSW M parameter', default: '16' },
     ],
     examples: [
-        { command: 'claude-flow embeddings index', description: 'Show index status' },
-        { command: 'claude-flow embeddings index -a build -c documents', description: 'Build index' },
-        { command: 'claude-flow embeddings index -a optimize -c patterns', description: 'Optimize index' },
+        { command: 'odd-flow embeddings index', description: 'Show index status' },
+        { command: 'odd-flow embeddings index -a build -c documents', description: 'Build index' },
+        { command: 'odd-flow embeddings index -a optimize -c patterns', description: 'Optimize index' },
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'status';
@@ -519,7 +519,7 @@ const indexCommand = {
                 else {
                     output.writeln();
                     output.printInfo('Index is empty. Store some entries to populate it.');
-                    output.printInfo('Run: claude-flow memory store -k "key" --value "text"');
+                    output.printInfo('Run: odd-flow memory store -k "key" --value "text"');
                 }
                 return { success: true, data: status };
             }
@@ -579,11 +579,11 @@ const initCommand = {
         { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite existing configuration', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow embeddings init', description: 'Initialize with defaults' },
-        { command: 'claude-flow embeddings init --model all-mpnet-base-v2', description: 'Use higher quality model' },
-        { command: 'claude-flow embeddings init --no-hyperbolic', description: 'Euclidean only' },
-        { command: 'claude-flow embeddings init --curvature=-0.5', description: 'Custom curvature (use = for negative)' },
-        { command: 'claude-flow embeddings init --force', description: 'Overwrite existing config' },
+        { command: 'odd-flow embeddings init', description: 'Initialize with defaults' },
+        { command: 'odd-flow embeddings init --model all-mpnet-base-v2', description: 'Use higher quality model' },
+        { command: 'odd-flow embeddings init --no-hyperbolic', description: 'Euclidean only' },
+        { command: 'odd-flow embeddings init --curvature=-0.5', description: 'Custom curvature (use = for negative)' },
+        { command: 'odd-flow embeddings init --force', description: 'Overwrite existing config' },
     ],
     action: async (ctx) => {
         const model = ctx.flags.model || 'all-MiniLM-L6-v2';
@@ -603,7 +603,7 @@ const initCommand = {
             const fs = await import('fs');
             const path = await import('path');
             // Create directories
-            const configDir = path.join(process.cwd(), '.claude-flow');
+            const configDir = path.join(process.cwd(), '.odd-flow');
             const modelDir = path.join(configDir, 'models');
             const configPath = path.join(configDir, 'embeddings.json');
             // Check for existing config
@@ -634,7 +634,7 @@ const initCommand = {
                 else {
                     // Simulate download for when embeddings package not available
                     await new Promise(r => setTimeout(r, 500));
-                    output.writeln(output.dim('  (Simulated - @claude-flow/embeddings not installed)'));
+                    output.writeln(output.dim('  (Simulated - @odd-flow/embeddings not installed)'));
                 }
             }
             // Write embeddings config
@@ -708,7 +708,7 @@ const providersCommand = {
     description: 'List available embedding providers',
     options: [],
     examples: [
-        { command: 'claude-flow embeddings providers', description: 'List providers' },
+        { command: 'odd-flow embeddings providers', description: 'List providers' },
     ],
     action: async () => {
         output.writeln();
@@ -747,8 +747,8 @@ const chunkCommand = {
         { name: 'file', short: 'f', type: 'string', description: 'File to chunk (instead of text)' },
     ],
     examples: [
-        { command: 'claude-flow embeddings chunk -t "Long text..." -s 256', description: 'Chunk with 256 char limit' },
-        { command: 'claude-flow embeddings chunk -f doc.txt --strategy paragraph', description: 'Chunk file by paragraph' },
+        { command: 'odd-flow embeddings chunk -t "Long text..." -s 256', description: 'Chunk with 256 char limit' },
+        { command: 'odd-flow embeddings chunk -f doc.txt --strategy paragraph', description: 'Chunk file by paragraph' },
     ],
     action: async (ctx) => {
         const embeddings = await getEmbeddings();
@@ -760,7 +760,7 @@ const chunkCommand = {
         output.writeln(output.bold('Document Chunking'));
         output.writeln(output.dim('─'.repeat(50)));
         if (!embeddings) {
-            output.printWarning('@claude-flow/embeddings not installed, showing preview');
+            output.printWarning('@odd-flow/embeddings not installed, showing preview');
             output.writeln();
             output.printBox([
                 `Strategy: ${strategy}`,
@@ -802,8 +802,8 @@ const normalizeCommand = {
         { name: 'check', short: 'c', type: 'boolean', description: 'Check if already normalized' },
     ],
     examples: [
-        { command: 'claude-flow embeddings normalize -i "[0.5, 0.3, 0.8]" -t l2', description: 'L2 normalize' },
-        { command: 'claude-flow embeddings normalize --check -i "[...]"', description: 'Check if normalized' },
+        { command: 'odd-flow embeddings normalize -i "[0.5, 0.3, 0.8]" -t l2', description: 'L2 normalize' },
+        { command: 'odd-flow embeddings normalize --check -i "[...]"', description: 'Check if normalized' },
     ],
     action: async (ctx) => {
         const type = ctx.flags.type || 'l2';
@@ -840,8 +840,8 @@ const hyperbolicCommand = {
         { name: 'input', short: 'i', type: 'string', description: 'Input embedding(s) JSON' },
     ],
     examples: [
-        { command: 'claude-flow embeddings hyperbolic -a convert -i "[0.5, 0.3]"', description: 'Convert to Poincaré' },
-        { command: 'claude-flow embeddings hyperbolic -a distance', description: 'Compute hyperbolic distance' },
+        { command: 'odd-flow embeddings hyperbolic -a convert -i "[0.5, 0.3]"', description: 'Convert to Poincaré' },
+        { command: 'odd-flow embeddings hyperbolic -a distance', description: 'Compute hyperbolic distance' },
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'convert';
@@ -853,10 +853,10 @@ const hyperbolicCommand = {
         output.writeln(output.dim('─'.repeat(50)));
         // Try to import hyperbolic functions from embeddings package
         try {
-            const hyperbolic = await import('@claude-flow/embeddings').then(m => m).catch(() => null);
+            const hyperbolic = await import('@odd-flow/embeddings').then(m => m).catch(() => null);
             if (!hyperbolic || !hyperbolic.euclideanToPoincare) {
-                output.printWarning('@claude-flow/embeddings hyperbolic module not available');
-                output.printInfo('Install with: npm install @claude-flow/embeddings');
+                output.printWarning('@odd-flow/embeddings hyperbolic module not available');
+                output.printInfo('Install with: npm install @odd-flow/embeddings');
                 return { success: false, exitCode: 1 };
             }
             if (!inputJson) {
@@ -892,7 +892,7 @@ const hyperbolicCommand = {
                     output.writeln(output.success('Euclidean → Poincaré conversion:'));
                     output.writeln();
                     output.writeln(`Input (Euclidean):  [${vec.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${vec.length > 6 ? ', ...' : ''}]`);
-                    output.writeln(`Output (Poincaré):  [${result.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${result.length > 6 ? ', ...' : ''}]`);
+                    output.writeln(`Output (Poincaré):  [${result.slice(0, 6).map((v) => v.toFixed(4)).join(', ')}${result.length > 6 ? ', ...' : ''}]`);
                     output.writeln(`Curvature: ${curvature}`);
                     output.writeln(`Norm: ${Math.sqrt(result.reduce((s, v) => s + v * v, 0)).toFixed(6)} (must be < 1)`);
                     return { success: true, data: { result } };
@@ -922,7 +922,7 @@ const hyperbolicCommand = {
                     output.writeln(output.success('Hyperbolic centroid (Fréchet mean):'));
                     output.writeln();
                     output.writeln(`Input vectors: ${vectors.length}`);
-                    output.writeln(`Centroid: [${centroid.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${centroid.length > 6 ? ', ...' : ''}]`);
+                    output.writeln(`Centroid: [${centroid.slice(0, 6).map((v) => v.toFixed(4)).join(', ')}${centroid.length > 6 ? ', ...' : ''}]`);
                     return { success: true, data: { centroid } };
                 }
                 default:
@@ -948,11 +948,11 @@ const neuralCommand = {
         { name: 'consolidation-interval', type: 'string', description: 'Memory consolidation interval (ms)', default: '60000' },
     ],
     examples: [
-        { command: 'claude-flow embeddings neural --init', description: 'Initialize RuVector substrate' },
-        { command: 'claude-flow embeddings neural -f drift', description: 'Semantic drift detection' },
-        { command: 'claude-flow embeddings neural -f memory', description: 'Memory physics (hippocampal)' },
-        { command: 'claude-flow embeddings neural -f coherence', description: 'Safety & alignment monitoring' },
-        { command: 'claude-flow embeddings neural --drift-threshold=0.2', description: 'Custom drift threshold' },
+        { command: 'odd-flow embeddings neural --init', description: 'Initialize RuVector substrate' },
+        { command: 'odd-flow embeddings neural -f drift', description: 'Semantic drift detection' },
+        { command: 'odd-flow embeddings neural -f memory', description: 'Memory physics (hippocampal)' },
+        { command: 'odd-flow embeddings neural -f coherence', description: 'Safety & alignment monitoring' },
+        { command: 'odd-flow embeddings neural --drift-threshold=0.2', description: 'Custom drift threshold' },
     ],
     action: async (ctx) => {
         const feature = ctx.flags.feature || 'all';
@@ -967,7 +967,7 @@ const neuralCommand = {
         // Check if embeddings config exists
         const fs = await import('fs');
         const path = await import('path');
-        const configPath = path.join(process.cwd(), '.claude-flow', 'embeddings.json');
+        const configPath = path.join(process.cwd(), '.odd-flow', 'embeddings.json');
         if (!fs.existsSync(configPath)) {
             output.printWarning('Embeddings not initialized');
             output.printInfo('Run "embeddings init" first to configure ONNX model');
@@ -1080,7 +1080,7 @@ const neuralCommand = {
             output.printInfo('Run with --init to enable neural substrate');
         }
         else {
-            output.writeln(output.dim('Configuration: .claude-flow/embeddings.json'));
+            output.writeln(output.dim('Configuration: .odd-flow/embeddings.json'));
             output.writeln(output.dim('Next: Use "hooks pretrain" to train patterns'));
         }
         return { success: true, data: { config: neuralConfig, feature } };
@@ -1095,8 +1095,8 @@ const modelsCommand = {
         { name: 'list', short: 'l', type: 'boolean', description: 'List available models', default: 'true' },
     ],
     examples: [
-        { command: 'claude-flow embeddings models', description: 'List models' },
-        { command: 'claude-flow embeddings models -d all-MiniLM-L6-v2', description: 'Download model' },
+        { command: 'odd-flow embeddings models', description: 'List models' },
+        { command: 'odd-flow embeddings models -d all-MiniLM-L6-v2', description: 'Download model' },
     ],
     action: async (ctx) => {
         const download = ctx.flags.download;
@@ -1165,8 +1165,8 @@ const cacheCommand = {
         { name: 'db-path', type: 'string', description: 'SQLite database path', default: '.cache/embeddings.db' },
     ],
     examples: [
-        { command: 'claude-flow embeddings cache', description: 'Show cache stats' },
-        { command: 'claude-flow embeddings cache -a clear', description: 'Clear cache' },
+        { command: 'odd-flow embeddings cache', description: 'Show cache stats' },
+        { command: 'odd-flow embeddings cache -a clear', description: 'Clear cache' },
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'stats';
@@ -1295,8 +1295,8 @@ const warmupCommand = {
         { name: 'test', short: 't', type: 'boolean', description: 'Run test embedding after warmup', default: 'true' },
     ],
     examples: [
-        { command: 'claude-flow embeddings warmup', description: 'Preload model with test' },
-        { command: 'claude-flow embeddings warmup -b', description: 'Background warmup' },
+        { command: 'odd-flow embeddings warmup', description: 'Preload model with test' },
+        { command: 'odd-flow embeddings warmup -b', description: 'Background warmup' },
     ],
     action: async (ctx) => {
         const runTest = ctx.flags.test !== false;
@@ -1369,8 +1369,8 @@ const benchmarkCommand = {
         { name: 'full', short: 'f', type: 'boolean', description: 'Run full benchmark suite', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow embeddings benchmark', description: 'Quick benchmark' },
-        { command: 'claude-flow embeddings benchmark -n 50 -f', description: 'Full benchmark' },
+        { command: 'odd-flow embeddings benchmark', description: 'Quick benchmark' },
+        { command: 'odd-flow embeddings benchmark -n 50 -f', description: 'Full benchmark' },
     ],
     action: async (ctx) => {
         const iterations = parseInt(ctx.flags.iterations || '10', 10);
@@ -1524,13 +1524,13 @@ export const embeddingsCommand = {
         benchmarkCommand,
     ],
     examples: [
-        { command: 'claude-flow embeddings init', description: 'Initialize ONNX embedding system' },
-        { command: 'claude-flow embeddings init --model all-mpnet-base-v2', description: 'Init with larger model' },
-        { command: 'claude-flow embeddings generate -t "Hello"', description: 'Generate embedding' },
-        { command: 'claude-flow embeddings search -q "error handling"', description: 'Semantic search' },
-        { command: 'claude-flow embeddings chunk -t "Long doc..."', description: 'Chunk document' },
-        { command: 'claude-flow embeddings hyperbolic -a convert', description: 'Hyperbolic space' },
-        { command: 'claude-flow embed neural -f drift', description: 'Neural substrate' },
+        { command: 'odd-flow embeddings init', description: 'Initialize ONNX embedding system' },
+        { command: 'odd-flow embeddings init --model all-mpnet-base-v2', description: 'Init with larger model' },
+        { command: 'odd-flow embeddings generate -t "Hello"', description: 'Generate embedding' },
+        { command: 'odd-flow embeddings search -q "error handling"', description: 'Semantic search' },
+        { command: 'odd-flow embeddings chunk -t "Long doc..."', description: 'Chunk document' },
+        { command: 'odd-flow embeddings hyperbolic -a convert', description: 'Hyperbolic space' },
+        { command: 'odd-flow embed neural -f drift', description: 'Neural substrate' },
     ],
     action: async () => {
         output.writeln();

package/v3/@odd-flow/cli/dist/src/commands/escalation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * V3 CLI Escalation Command
+ * Severity-based problem routing (P0/P1/P2)
+ */
+import type { Command } from '../types.js';
+export declare const escalationCommand: Command;
+//# sourceMappingURL=escalation.d.ts.map

package/v3/@odd-flow/cli/dist/src/commands/escalation.js

@@ -0,0 +1,115 @@
+/**
+ * V3 CLI Escalation Command
+ * Severity-based problem routing (P0/P1/P2)
+ */
+import { output } from '../output.js';
+import { callMCPTool } from '../mcp-client.js';
+const statusSubcommand = {
+    name: 'status',
+    description: 'Show current escalation state',
+    options: [
+        { name: 'severity', short: 's', type: 'string', description: 'Filter by severity (p0, p1, p2)' },
+    ],
+    action: async (ctx) => {
+        try {
+            const result = await callMCPTool('escalation_status', {
+                severity: ctx.flags?.severity,
+            });
+            output.writeln(output.bold('Escalation Status'));
+            output.writeln(JSON.stringify(result, null, 2));
+            return { success: true };
+        }
+        catch (error) {
+            output.error(`Failed to get escalation status: ${error}`);
+            return { success: false };
+        }
+    },
+};
+const logSubcommand = {
+    name: 'log',
+    description: 'Show full escalation history',
+    options: [],
+    action: async (_ctx) => {
+        try {
+            const result = await callMCPTool('escalation_status', {});
+            output.writeln(output.bold('Escalation Log'));
+            output.writeln(JSON.stringify(result, null, 2));
+            return { success: true };
+        }
+        catch (error) {
+            output.error(`Failed to get escalation log: ${error}`);
+            return { success: false };
+        }
+    },
+};
+const summarySubcommand = {
+    name: 'summary',
+    description: 'Show batched P2 summary grouped by category',
+    options: [],
+    action: async (_ctx) => {
+        try {
+            const result = await callMCPTool('escalation_status', {});
+            output.writeln(output.bold('Escalation Summary'));
+            output.writeln(JSON.stringify(result, null, 2));
+            return { success: true };
+        }
+        catch (error) {
+            output.error(`Failed to get escalation summary: ${error}`);
+            return { success: false };
+        }
+    },
+};
+const reclassifySubcommand = {
+    name: 'reclassify',
+    description: 'Reclassify an escalation event to a different severity',
+    options: [
+        { name: 'severity', short: 's', type: 'string', description: 'New severity (p0, p1, p2)', required: true },
+    ],
+    action: async (ctx) => {
+        const eventId = ctx.args?.[0];
+        const severity = ctx.flags?.severity;
+        if (!eventId || !severity) {
+            output.error('Usage: odd-flow escalation reclassify <eventId> --severity <p0|p1|p2>');
+            return { success: false };
+        }
+        try {
+            const result = await callMCPTool('escalation_resolve', {
+                eventId,
+                reclassifyTo: severity,
+            });
+            output.writeln(JSON.stringify(result, null, 2));
+            return { success: true };
+        }
+        catch (error) {
+            output.error(`Failed to reclassify: ${error}`);
+            return { success: false };
+        }
+    },
+};
+export const escalationCommand = {
+    name: 'escalation',
+    description: 'Severity-based problem routing (P0/P1/P2)',
+    subcommands: [statusSubcommand, logSubcommand, summarySubcommand, reclassifySubcommand],
+    options: [],
+    examples: [
+        { command: 'odd-flow escalation status', description: 'Show open escalations' },
+        { command: 'odd-flow escalation summary', description: 'Show P2 summary' },
+        { command: 'odd-flow escalation reclassify evt-123 --severity p2', description: 'Downgrade to P2' },
+    ],
+    action: async (_ctx) => {
+        output.writeln();
+        output.writeln(output.bold('Escalation — Problem Routing'));
+        output.writeln();
+        output.writeln('Usage: odd-flow escalation <subcommand>');
+        output.writeln();
+        output.writeln('Subcommands:');
+        output.printList([
+            `${output.highlight('status')}      - Show current escalation state`,
+            `${output.highlight('log')}         - Show full escalation history`,
+            `${output.highlight('summary')}     - Show batched P2 summary`,
+            `${output.highlight('reclassify')}  - Reclassify event severity`,
+        ]);
+        return { success: true };
+    },
+};
+//# sourceMappingURL=escalation.js.map

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/commands/guidance.js

@@ -14,9 +14,9 @@ const compileCommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow guidance compile', description: 'Compile default CLAUDE.md' },
-        { command: 'claude-flow guidance compile -r ./CLAUDE.md -l ./CLAUDE.local.md', description: 'Compile with local overlay' },
-        { command: 'claude-flow guidance compile --json', description: 'Output compiled bundle as JSON' },
+        { command: 'odd-flow guidance compile', description: 'Compile default CLAUDE.md' },
+        { command: 'odd-flow guidance compile -r ./CLAUDE.md -l ./CLAUDE.local.md', description: 'Compile with local overlay' },
+        { command: 'odd-flow guidance compile --json', description: 'Output compiled bundle as JSON' },
     ],
     action: async (ctx) => {
         const rootPath = ctx.flags.root || './CLAUDE.md';
@@ -37,7 +37,7 @@ const compileCommand = {
             if (localPath && existsSync(localPath)) {
                 localContent = await readFile(localPath, 'utf-8');
             }
-            const { GuidanceCompiler } = await import('@claude-flow/guidance/compiler');
+            const { GuidanceCompiler } = await import('@odd-flow/guidance/compiler');
             const compiler = new GuidanceCompiler();
             const bundle = compiler.compile(rootContent, localContent);
             if (jsonOutput) {
@@ -88,8 +88,8 @@ const retrieveCommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow guidance retrieve -t "Fix SQL injection in user search"', description: 'Retrieve guidance for a security task' },
-        { command: 'claude-flow guidance retrieve -t "Add unit tests" -n 3', description: 'Retrieve top 3 shards for testing' },
+        { command: 'odd-flow guidance retrieve -t "Fix SQL injection in user search"', description: 'Retrieve guidance for a security task' },
+        { command: 'odd-flow guidance retrieve -t "Add unit tests" -n 3', description: 'Retrieve top 3 shards for testing' },
     ],
     action: async (ctx) => {
         const task = ctx.flags.task;
@@ -108,8 +108,8 @@ const retrieveCommand = {
         try {
             const { readFile } = await import('node:fs/promises');
             const { existsSync } = await import('node:fs');
-            const { GuidanceCompiler } = await import('@claude-flow/guidance/compiler');
-            const { ShardRetriever, HashEmbeddingProvider } = await import('@claude-flow/guidance/retriever');
+            const { GuidanceCompiler } = await import('@odd-flow/guidance/compiler');
+            const { ShardRetriever, HashEmbeddingProvider } = await import('@odd-flow/guidance/retriever');
             if (!existsSync(rootPath)) {
                 output.writeln(output.error(`Root guidance file not found: ${rootPath}`));
                 return { success: false, message: `File not found: ${rootPath}` };
@@ -173,8 +173,8 @@ const gatesCommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow guidance gates -c "rm -rf /tmp"', description: 'Check if a command is destructive' },
-        { command: 'claude-flow guidance gates --content "api_key=sk-abc123..."', description: 'Check content for secrets' },
+        { command: 'odd-flow guidance gates -c "rm -rf /tmp"', description: 'Check if a command is destructive' },
+        { command: 'odd-flow guidance gates --content "api_key=sk-abc123..."', description: 'Check content for secrets' },
     ],
     action: async (ctx) => {
         const command = ctx.flags.command;
@@ -185,7 +185,7 @@ const gatesCommand = {
         output.writeln(output.bold('Enforcement Gates'));
         output.writeln(output.dim('─'.repeat(50)));
         try {
-            const { EnforcementGates } = await import('@claude-flow/guidance/gates');
+            const { EnforcementGates } = await import('@odd-flow/guidance/gates');
             const gates = new EnforcementGates();
             const results = [];
             if (command) {
@@ -268,7 +268,7 @@ const statusCommand = {
             const statusData = {
                 rootGuidance: rootExists ? 'found' : 'not found',
                 localOverlay: localExists ? 'found' : 'not configured',
-                dataDir: existsSync('./.claude-flow/guidance') ? 'exists' : 'not created',
+                dataDir: existsSync('./.odd-flow/guidance') ? 'exists' : 'not created',
             };
             if (jsonOutput) {
                 output.writeln(JSON.stringify(statusData, null, 2));
@@ -279,7 +279,7 @@ const statusCommand = {
                 output.writeln(`  Data directory: ${statusData.dataDir === 'exists' ? output.success('exists') : output.dim('not created')}`);
                 if (rootExists) {
                     const { readFile } = await import('node:fs/promises');
-                    const { GuidanceCompiler } = await import('@claude-flow/guidance/compiler');
+                    const { GuidanceCompiler } = await import('@odd-flow/guidance/compiler');
                     const rootContent = await readFile('./CLAUDE.md', 'utf-8');
                     const compiler = new GuidanceCompiler();
                     const bundle = compiler.compile(rootContent);
@@ -314,10 +314,10 @@ const optimizeCommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow guidance optimize', description: 'Analyze current CLAUDE.md and show suggestions' },
-        { command: 'claude-flow guidance optimize --apply', description: 'Apply optimizations to CLAUDE.md' },
-        { command: 'claude-flow guidance optimize -s compact --apply', description: 'Optimize for compact context window' },
-        { command: 'claude-flow guidance optimize --target-score 95', description: 'Optimize until score reaches 95' },
+        { command: 'odd-flow guidance optimize', description: 'Analyze current CLAUDE.md and show suggestions' },
+        { command: 'odd-flow guidance optimize --apply', description: 'Apply optimizations to CLAUDE.md' },
+        { command: 'odd-flow guidance optimize -s compact --apply', description: 'Optimize for compact context window' },
+        { command: 'odd-flow guidance optimize --target-score 95', description: 'Optimize until score reaches 95' },
     ],
     action: async (ctx) => {
         const rootPath = ctx.flags.root || './CLAUDE.md';
@@ -343,7 +343,7 @@ const optimizeCommand = {
                 localContent = await readFile(localPath, 'utf-8');
             }
             // Step 1: Analyze current state
-            const { analyze, formatReport, optimizeForSize, formatBenchmark } = await import('@claude-flow/guidance/analyzer');
+            const { analyze, formatReport, optimizeForSize, formatBenchmark } = await import('@odd-flow/guidance/analyzer');
             const analysis = analyze(rootContent, localContent);
             if (jsonOutput && !applyChanges) {
                 output.writeln(JSON.stringify(analysis, null, 2));
@@ -417,10 +417,10 @@ const abTestCommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow guidance ab-test', description: 'Run default A/B test (no guidance vs ./CLAUDE.md)' },
-        { command: 'claude-flow guidance ab-test -a old.md -b new.md', description: 'Compare two CLAUDE.md versions' },
-        { command: 'claude-flow guidance ab-test --tasks custom-tasks.json', description: 'Run with custom test tasks' },
-        { command: 'claude-flow guidance ab-test --json', description: 'Output full report as JSON' },
+        { command: 'odd-flow guidance ab-test', description: 'Run default A/B test (no guidance vs ./CLAUDE.md)' },
+        { command: 'odd-flow guidance ab-test -a old.md -b new.md', description: 'Compare two CLAUDE.md versions' },
+        { command: 'odd-flow guidance ab-test --tasks custom-tasks.json', description: 'Run with custom test tasks' },
+        { command: 'odd-flow guidance ab-test --json', description: 'Output full report as JSON' },
     ],
     action: async (ctx) => {
         const configAPath = ctx.flags['config-a'];
@@ -434,7 +434,7 @@ const abTestCommand = {
         try {
             const { readFile } = await import('node:fs/promises');
             const { existsSync } = await import('node:fs');
-            const { abBenchmark, getDefaultABTasks } = await import('@claude-flow/guidance/analyzer');
+            const { abBenchmark, getDefaultABTasks } = await import('@odd-flow/guidance/analyzer');
             // Load Config B (candidate) content
             if (!existsSync(configBPath)) {
                 output.writeln(output.error(`Config B file not found: ${configBPath}`));
@@ -532,12 +532,12 @@ export const guidanceCommand = {
     ],
     options: [],
     examples: [
-        { command: 'claude-flow guidance compile', description: 'Compile CLAUDE.md into policy bundle' },
-        { command: 'claude-flow guidance retrieve -t "Fix auth bug"', description: 'Retrieve relevant guidance' },
-        { command: 'claude-flow guidance gates -c "rm -rf /"', description: 'Check enforcement gates' },
-        { command: 'claude-flow guidance status', description: 'Show control plane status' },
-        { command: 'claude-flow guidance optimize', description: 'Analyze and optimize CLAUDE.md' },
-        { command: 'claude-flow guidance ab-test', description: 'Run A/B behavioral comparison' },
+        { command: 'odd-flow guidance compile', description: 'Compile CLAUDE.md into policy bundle' },
+        { command: 'odd-flow guidance retrieve -t "Fix auth bug"', description: 'Retrieve relevant guidance' },
+        { command: 'odd-flow guidance gates -c "rm -rf /"', description: 'Check enforcement gates' },
+        { command: 'odd-flow guidance status', description: 'Show control plane status' },
+        { command: 'odd-flow guidance optimize', description: 'Analyze and optimize CLAUDE.md' },
+        { command: 'odd-flow guidance ab-test', description: 'Run A/B behavioral comparison' },
     ],
     action: async (ctx) => {
         output.writeln();
@@ -552,7 +552,7 @@ export const guidanceCommand = {
         output.writeln(`  ${output.bold('optimize')}  Analyze and optimize CLAUDE.md`);
         output.writeln(`  ${output.bold('ab-test')}   Run A/B behavioral comparison`);
         output.writeln();
-        output.writeln(output.dim('Use claude-flow guidance <subcommand> --help for details'));
+        output.writeln(output.dim('Use odd-flow guidance <subcommand> --help for details'));
         return { success: true };
     },
 };