odd-flow 1.0.0 → 1.2.0

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/hooks-tools.js

@@ -124,7 +124,7 @@ function generateSimpleEmbedding(text, dimension = 384) {
 }
 // ── Runtime routing outcome persistence ──────────────────────────────
 // Closes the learning loop: post-task records outcomes → route loads them.
-const ROUTING_OUTCOMES_PATH = join(resolve('.'), '.claude-flow/routing-outcomes.json');
+const ROUTING_OUTCOMES_PATH = join(resolve('.'), '.odd-flow/routing-outcomes.json');
 const ROUTING_STOPWORDS = new Set([
     'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
     'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall', 'can',
@@ -361,7 +361,7 @@ async function getLoRAAdapter() {
 }
 // In-memory trajectory tracking (persisted on end)
 const activeTrajectories = new Map();
-const MEMORY_DIR = '.claude-flow/memory';
+const MEMORY_DIR = '.odd-flow/memory';
 const MEMORY_FILE = 'store.json';
 function getMemoryPath() {
     return resolve(join(MEMORY_DIR, MEMORY_FILE));
@@ -2118,7 +2118,7 @@ export const hooksPatternSearch = {
             results: [],
             searchTimeMs: 0,
             backend: 'unavailable',
-            note: 'Real vector search not available. Initialize memory database with: claude-flow memory init',
+            note: 'Real vector search not available. Initialize memory database with: odd-flow memory init',
         };
     },
 };

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/index.d.ts

@@ -19,4 +19,7 @@ export { progressTools } from './progress-tools.js';
 export { securityTools } from './security-tools.js';
 export { embeddingsTools } from './embeddings-tools.js';
 export { claimsTools } from './claims-tools.js';
+export { refineryTools } from './refinery-tools.js';
+export { escalationTools } from './escalation-tools.js';
+export { schedulerTools } from './scheduler-tools.js';
 //# sourceMappingURL=index.d.ts.map

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/index.js

@@ -18,4 +18,8 @@ export { progressTools } from './progress-tools.js';
 export { securityTools } from './security-tools.js';
 export { embeddingsTools } from './embeddings-tools.js';
 export { claimsTools } from './claims-tools.js';
+// Phase D: Gastown Augmentation
+export { refineryTools } from './refinery-tools.js';
+export { escalationTools } from './escalation-tools.js';
+export { schedulerTools } from './scheduler-tools.js';
 //# sourceMappingURL=index.js.map

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/memory-tools.js

@@ -12,7 +12,7 @@
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 // Paths
-const MEMORY_DIR = '.claude-flow/memory';
+const MEMORY_DIR = '.odd-flow/memory';
 const LEGACY_MEMORY_FILE = 'store.json';
 const MIGRATION_MARKER = '.migrated-to-sqlite';
 function getMemoryDir() {

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/neural-tools.d.ts

@@ -4,12 +4,12 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses @claude-flow/embeddings for REAL embeddings when available
- * - Falls back to simulated embeddings when @claude-flow/embeddings not installed
+ * - Uses @odd-flow/embeddings for REAL embeddings when available
+ * - Falls back to simulated embeddings when @odd-flow/embeddings not installed
  * - Pattern storage and search with cosine similarity
  * - Training progress tracked (actual model training requires external tools)
  *
- * Note: For production neural features, use @claude-flow/neural module
+ * Note: For production neural features, use @odd-flow/neural module
  */
 import type { MCPTool } from './types.js';
 export declare const neuralTools: MCPTool[];

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/neural-tools.js

@@ -4,16 +4,16 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses @claude-flow/embeddings for REAL embeddings when available
- * - Falls back to simulated embeddings when @claude-flow/embeddings not installed
+ * - Uses @odd-flow/embeddings for REAL embeddings when available
+ * - Falls back to simulated embeddings when @odd-flow/embeddings not installed
  * - Pattern storage and search with cosine similarity
  * - Training progress tracked (actual model training requires external tools)
  *
- * Note: For production neural features, use @claude-flow/neural module
+ * Note: For production neural features, use @odd-flow/neural module
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-// Try to import real embeddings — prefer agentic-flow v3 ReasoningBank, then @claude-flow/embeddings
+// Try to import real embeddings — prefer agentic-flow v3 ReasoningBank, then @odd-flow/embeddings
 let realEmbeddings = null;
 let embeddingServiceName = 'none';
 try {
@@ -23,9 +23,9 @@ try {
         realEmbeddings = { embed: (text) => rb.computeEmbedding(text) };
         embeddingServiceName = 'agentic-flow/reasoningbank';
     }
-    // Tier 2: @claude-flow/embeddings
+    // Tier 2: @odd-flow/embeddings
     if (!realEmbeddings) {
-        const embeddingsModule = await import('@claude-flow/embeddings').catch(() => null);
+        const embeddingsModule = await import('@odd-flow/embeddings').catch(() => null);
         if (embeddingsModule?.createEmbeddingService) {
             try {
                 const service = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
@@ -54,7 +54,7 @@ catch {
     // No embedding provider available, will use fallback
 }
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
+const STORAGE_DIR = '.odd-flow';
 const NEURAL_DIR = 'neural';
 const MODELS_FILE = 'models.json';
 const PATTERNS_FILE = 'patterns.json';
@@ -389,7 +389,7 @@ export const neuralTools = [
             const patterns = Object.values(store.patterns);
             return {
                 _realEmbeddings: !!realEmbeddings,
-                embeddingProvider: realEmbeddings ? `@claude-flow/embeddings (${embeddingServiceName})` : 'hash-based (deterministic)',
+                embeddingProvider: realEmbeddings ? `@odd-flow/embeddings (${embeddingServiceName})` : 'hash-based (deterministic)',
                 models: {
                     total: models.length,
                     ready: models.filter(m => m.status === 'ready').length,

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/performance-tools.js

@@ -15,7 +15,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import * as os from 'node:os';
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
+const STORAGE_DIR = '.odd-flow';
 const PERF_DIR = 'performance';
 const METRICS_FILE = 'metrics.json';
 const BENCHMARKS_FILE = 'benchmarks.json';

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/progress-tools.d.ts

@@ -3,7 +3,7 @@
  *
  * Provides MCP tools for checking and syncing V3 implementation progress.
  *
- * @module @claude-flow/cli/mcp-tools/progress
+ * @module @odd-flow/cli/mcp-tools/progress
  */
 import type { MCPTool } from './types.js';
 /**

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/progress-tools.js

@@ -3,7 +3,7 @@
  *
  * Provides MCP tools for checking and syncing V3 implementation progress.
  *
- * @module @claude-flow/cli/mcp-tools/progress
+ * @module @odd-flow/cli/mcp-tools/progress
  */
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, basename, dirname } from 'path';
@@ -12,9 +12,9 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // From dist/src/mcp-tools or src/mcp-tools, navigate to v3 directory
-// CLI is at v3/@claude-flow/cli, so go up 2 levels from cli to get to v3
+// CLI is at v3/@odd-flow/cli, so go up 2 levels from cli to get to v3
 const CLI_ROOT = join(__dirname, '../../..');
-const CLAUDE_FLOW_DIR = join(CLI_ROOT, '..'); // @claude-flow directory
+const CLAUDE_FLOW_DIR = join(CLI_ROOT, '..'); // @odd-flow directory
 const V3_DIR = join(CLAUDE_FLOW_DIR, '..'); // v3 directory
 const PROJECT_ROOT = join(V3_DIR, '..');
 // Utility/service packages follow DDD differently - their services ARE the application layer
@@ -92,7 +92,7 @@ function calculateModuleProgress(moduleDir) {
 async function calculateProgress() {
     const now = new Date().toISOString();
     // Count V3 modules
-    const modulesDir = join(V3_DIR, '@claude-flow');
+    const modulesDir = join(V3_DIR, '@odd-flow');
     const modules = [];
     let totalProgress = 0;
     let explicitDDD = 0;
@@ -119,7 +119,7 @@ async function calculateProgress() {
     const totalStats = countFilesAndLines(V3_DIR);
     // Count CLI commands (from commands/index.ts)
     let cliCommands = 28; // Default to known count
-    const commandsIndexPath = join(V3_DIR, '@claude-flow/cli/src/commands/index.ts');
+    const commandsIndexPath = join(V3_DIR, '@odd-flow/cli/src/commands/index.ts');
     if (existsSync(commandsIndexPath)) {
         try {
             const content = readFileSync(commandsIndexPath, 'utf-8');
@@ -132,7 +132,7 @@ async function calculateProgress() {
     }
     // Count MCP tools
     let mcpTools = 100; // Approximate
-    const toolsIndexPath = join(V3_DIR, '@claude-flow/cli/src/mcp-tools/index.ts');
+    const toolsIndexPath = join(V3_DIR, '@odd-flow/cli/src/mcp-tools/index.ts');
     if (existsSync(toolsIndexPath)) {
         try {
             const content = readFileSync(toolsIndexPath, 'utf-8');
@@ -142,7 +142,7 @@ async function calculateProgress() {
     }
     // Count hooks subcommands (count const *Command definitions)
     let hooksSubcommands = 27; // Default to documented count
-    const hooksPath = join(V3_DIR, '@claude-flow/cli/src/commands/hooks.ts');
+    const hooksPath = join(V3_DIR, '@odd-flow/cli/src/commands/hooks.ts');
     if (existsSync(hooksPath)) {
         try {
             const content = readFileSync(hooksPath, 'utf-8');
@@ -186,7 +186,7 @@ async function calculateProgress() {
 async function syncProgress() {
     const metrics = await calculateProgress();
     // Persist to file
-    const metricsDir = join(PROJECT_ROOT, '.claude-flow/metrics');
+    const metricsDir = join(PROJECT_ROOT, '.odd-flow/metrics');
     if (!existsSync(metricsDir)) {
         mkdirSync(metricsDir, { recursive: true });
     }

package/v3/@odd-flow/cli/dist/src/mcp-tools/refinery-tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Refinery MCP Tools for CLI
+ *
+ * Implements MCP tools for the Refinery (merge queue) service.
+ * Provides programmatic access to changeset submission, conflict
+ * detection, and merge resolution for MCP clients.
+ *
+ * @module @odd-flow/cli/mcp-tools/refinery
+ */
+import type { MCPTool } from './types.js';
+import type { Refinery } from '../services/refinery.js';
+export declare function setActiveRefinery(refinery: Refinery | null): void;
+export declare function getActiveRefinery(): Refinery | null;
+export declare const refineryTools: MCPTool[];
+export default refineryTools;
+//# sourceMappingURL=refinery-tools.d.ts.map

package/v3/@odd-flow/cli/dist/src/mcp-tools/refinery-tools.js

@@ -0,0 +1,223 @@
+/**
+ * Refinery MCP Tools for CLI
+ *
+ * Implements MCP tools for the Refinery (merge queue) service.
+ * Provides programmatic access to changeset submission, conflict
+ * detection, and merge resolution for MCP clients.
+ *
+ * @module @odd-flow/cli/mcp-tools/refinery
+ */
+// Module-level singleton (started by swarm-tools.ts)
+let activeRefinery = null;
+export function setActiveRefinery(refinery) {
+    activeRefinery = refinery;
+}
+export function getActiveRefinery() {
+    return activeRefinery;
+}
+export const refineryTools = [
+    {
+        name: 'refinery_submit',
+        description: 'Submit agent changeset to the merge queue for conflict detection',
+        category: 'refinery',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: {
+                    type: 'string',
+                    description: 'ID of the agent submitting the changeset',
+                },
+                files: {
+                    type: 'array',
+                    description: 'Array of file changes to submit',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', description: 'File path' },
+                            content: { type: 'string', description: 'File content' },
+                        },
+                        required: ['path', 'content'],
+                    },
+                },
+                contracts: {
+                    type: 'array',
+                    description: 'Optional contract definitions for conflict detection',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Contract name' },
+                            fields: {
+                                type: 'array',
+                                description: 'Contract fields',
+                                items: { type: 'string' },
+                            },
+                        },
+                        required: ['name', 'fields'],
+                    },
+                },
+                taskId: {
+                    type: 'string',
+                    description: 'Optional task ID associated with this changeset',
+                },
+                role: {
+                    type: 'string',
+                    description: 'Optional role of the submitting agent',
+                },
+            },
+            required: ['agentId', 'files'],
+        },
+        handler: async (input) => {
+            if (!activeRefinery) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: false, error: 'No active refinery. Start a swarm first.' }),
+                        }],
+                    isError: true,
+                };
+            }
+            const agentId = input.agentId;
+            const files = input.files;
+            const contracts = input.contracts;
+            const taskId = input.taskId;
+            const role = input.role;
+            try {
+                const result = await activeRefinery.submit({
+                    agentId,
+                    files,
+                    contracts,
+                    taskId,
+                    role,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, ...result }),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error),
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+        },
+    },
+    {
+        name: 'refinery_status',
+        description: 'Get merge queue status including pending, committed, and conflicted changesets',
+        category: 'refinery',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            if (!activeRefinery) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ active: false }),
+                        }],
+                };
+            }
+            try {
+                const status = await activeRefinery.status();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ active: true, ...status }),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                active: true,
+                                error: error instanceof Error ? error.message : String(error),
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+        },
+    },
+    {
+        name: 'refinery_resolve',
+        description: 'Resolve a merge conflict by choosing version A, B, or providing merged content',
+        category: 'refinery',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                conflictId: {
+                    type: 'string',
+                    description: 'ID of the conflict to resolve',
+                },
+                resolution: {
+                    type: 'string',
+                    description: 'Resolution strategy',
+                    enum: ['A', 'B', 'merge'],
+                },
+                mergedContent: {
+                    type: 'string',
+                    description: 'Merged content when resolution is "merge"',
+                },
+            },
+            required: ['conflictId', 'resolution'],
+        },
+        handler: async (input) => {
+            if (!activeRefinery) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: false, error: 'No active refinery. Start a swarm first.' }),
+                        }],
+                    isError: true,
+                };
+            }
+            const conflictId = input.conflictId;
+            const resolution = input.resolution;
+            const mergedContent = input.mergedContent;
+            if (resolution === 'merge' && !mergedContent) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: false, error: 'mergedContent is required when resolution is "merge"' }),
+                        }],
+                    isError: true,
+                };
+            }
+            try {
+                activeRefinery.resolve(conflictId, resolution, mergedContent);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, conflictId, resolution }),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error),
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+        },
+    },
+];
+export default refineryTools;
+//# sourceMappingURL=refinery-tools.js.map

package/v3/@odd-flow/cli/dist/src/mcp-tools/scheduler-tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Scheduler MCP Tools for CLI
+ *
+ * Implements MCP tools for the Scheduler (D5) capacity governance service.
+ * Provides programmatic access to scheduler status and capacity reporting
+ * for MCP clients.
+ *
+ * @module @odd-flow/cli/mcp-tools/scheduler
+ */
+import type { MCPTool } from './types.js';
+import type { Scheduler } from '../services/scheduler.js';
+export declare function setActiveScheduler(scheduler: Scheduler | null): void;
+export declare function getActiveScheduler(): Scheduler | null;
+export declare const schedulerTools: MCPTool[];
+export default schedulerTools;
+//# sourceMappingURL=scheduler-tools.d.ts.map

package/v3/@odd-flow/cli/dist/src/mcp-tools/scheduler-tools.js

@@ -0,0 +1,72 @@
+/**
+ * Scheduler MCP Tools for CLI
+ *
+ * Implements MCP tools for the Scheduler (D5) capacity governance service.
+ * Provides programmatic access to scheduler status and capacity reporting
+ * for MCP clients.
+ *
+ * @module @odd-flow/cli/mcp-tools/scheduler
+ */
+// Module-level singleton (started by swarm-tools.ts)
+let activeScheduler = null;
+export function setActiveScheduler(scheduler) {
+    activeScheduler = scheduler;
+}
+export function getActiveScheduler() {
+    return activeScheduler;
+}
+export const schedulerTools = [
+    {
+        name: 'scheduler_status',
+        description: 'Get capacity scheduler status including agent count, scaling direction, and recent events',
+        category: 'scheduler',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                includeReport: {
+                    type: 'boolean',
+                    description: 'If true, include full capacity report',
+                },
+            },
+        },
+        handler: async (input) => {
+            if (!activeScheduler) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ active: false }),
+                        }],
+                };
+            }
+            const includeReport = input.includeReport;
+            try {
+                const status = await activeScheduler.status();
+                const result = { active: true, ...status };
+                if (includeReport) {
+                    const report = await activeScheduler.report();
+                    result.report = report;
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(result),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                active: true,
+                                error: error instanceof Error ? error.message : String(error),
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+        },
+    },
+];
+export default schedulerTools;
+//# sourceMappingURL=scheduler-tools.js.map

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/security-tools.js

@@ -19,7 +19,7 @@ async function getAIDefence() {
     if (aidefenceInstance) {
         return aidefenceInstance;
     }
-    const packageName = '@claude-flow/aidefence';
+    const packageName = '@odd-flow/aidefence';
     // First attempt - try to load via dynamic import (ESM)
     try {
         const aidefence = await import(packageName);
@@ -39,7 +39,7 @@ async function getAIDefence() {
         }
     }
     // No auto-install — package must be installed manually
-    throw new Error('AIDefence package not available. Install with: npm install @claude-flow/aidefence');
+    throw new Error('AIDefence package not available. Install with: npm install @odd-flow/aidefence');
 }
 /**
  * Scan input for AI manipulation threats
@@ -330,7 +330,7 @@ const aidefenceIsSafeTool = {
     handler: async (args) => {
         const input = args.input;
         try {
-            const { isSafe } = await import('@claude-flow/aidefence');
+            const { isSafe } = await import('@odd-flow/aidefence');
             const safe = isSafe(input);
             return {
                 content: [{

package/v3/{@claude-flow → @odd-flow}/cli/dist/src/mcp-tools/session-tools.js

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
+const STORAGE_DIR = '.odd-flow';
 const SESSION_DIR = 'sessions';
 function getSessionDir() {
     return join(process.cwd(), STORAGE_DIR, SESSION_DIR);