odd-flow 1.0.0 → 1.2.0

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

@@ -6,8 +6,18 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { WatchdogWitness } from '../services/watchdog-witness.js';
+import { WatchdogDeacon } from '../services/watchdog-deacon.js';
+import { WatchdogDogs } from '../services/watchdog-dogs.js';
+import { CheckpointManager } from '../services/checkpoint-manager.js';
+import { Refinery } from '../services/refinery.js';
+import { EscalationRouter } from '../services/escalation-router.js';
+import { Scheduler } from '../services/scheduler.js';
+import { setActiveRefinery } from './refinery-tools.js';
+import { setActiveRouter } from './escalation-tools.js';
+import { setActiveScheduler } from './scheduler-tools.js';
 // Swarm state persistence
-const SWARM_DIR = '.claude-flow/swarm';
+const SWARM_DIR = '.odd-flow/swarm';
 const SWARM_STATE_FILE = 'swarm-state.json';
 function getSwarmDir() {
     return join(process.cwd(), SWARM_DIR);
@@ -35,6 +45,105 @@ function saveSwarmStore(store) {
     ensureSwarmDir();
     writeFileSync(getSwarmStatePath(), JSON.stringify(store, null, 2), 'utf-8');
 }
+// Phase D service state (module-level singletons per process)
+let activeWitness = null;
+let activeDeacon = null;
+let activeDogs = null;
+let activeCheckpointMgr = null;
+let activeRefinery = null;
+let activeEscalation = null;
+let activeScheduler = null;
+function loadAgentRecords() {
+    try {
+        const path = join(process.cwd(), '.odd-flow/agents/store.json');
+        if (existsSync(path)) {
+            const store = JSON.parse(readFileSync(path, 'utf-8'));
+            return store.agents || {};
+        }
+    }
+    catch { /* empty */ }
+    return {};
+}
+function startPhaseDServices(config = {}, maxAgents = 8) {
+    // D1: Watchdog
+    if (config['watchdog.enabled'] !== false && !activeWitness) {
+        activeWitness = new WatchdogWitness({
+            checkInterval: config['watchdog.checkInterval'] || 15000,
+            heartbeatThreshold: config['watchdog.heartbeatThreshold'] || 60000,
+            enabled: true,
+        }, loadAgentRecords);
+        activeDeacon = new WatchdogDeacon(activeWitness, {
+            maxMissedBeats: config['watchdog.maxMissedBeats'] || 3,
+        });
+        activeDogs = new WatchdogDogs(activeDeacon, process.cwd());
+        activeWitness.start();
+    }
+    // D2: Checkpoint Manager (Session Recovery)
+    if (!activeCheckpointMgr) {
+        activeCheckpointMgr = new CheckpointManager(process.cwd());
+        const interval = config['recovery.checkpointInterval'] || 60000;
+        activeCheckpointMgr.start(interval);
+    }
+    // D3: Refinery (Merge Queue) — only for multi-agent swarms
+    if (config['refinery.enabled'] !== false && maxAgents > 1 && !activeRefinery) {
+        activeRefinery = new Refinery(process.cwd());
+        setActiveRefinery(activeRefinery);
+    }
+    // D4: Escalation Router
+    if (!activeEscalation) {
+        activeEscalation = new EscalationRouter(process.cwd());
+        setActiveRouter(activeEscalation);
+        // Wire watchdog events → escalation
+        if (activeDogs) {
+            activeDogs.on('watchdog:action-taken', (event) => {
+                activeEscalation?.report({
+                    severity: 'p1',
+                    source: 'watchdog',
+                    category: 'agent-terminated',
+                    description: `Watchdog terminated agent ${event.agentId}: ${event.reason || 'unresponsive'}`,
+                });
+            });
+        }
+        // Wire refinery conflicts → escalation
+        if (activeRefinery) {
+            activeRefinery.on('refinery:contract-conflict', (conflict) => {
+                activeEscalation?.report({
+                    severity: 'p0',
+                    source: 'refinery',
+                    category: 'contract-conflict',
+                    description: `Contract conflict: ${conflict.details || 'conflicting contract definitions'}`,
+                });
+            });
+        }
+    }
+    // D5: Scheduler (Capacity Governance)
+    if (config['scheduler.enabled'] !== false && !activeScheduler) {
+        activeScheduler = new Scheduler(process.cwd(), {
+            maxAgents,
+            checkInterval: config['scheduler.checkInterval'] || 30000,
+            idleThreshold: config['scheduler.idleThreshold'] || 2,
+            rampUp: config['scheduler.rampUp'] ?? true,
+            enabled: true,
+        });
+        setActiveScheduler(activeScheduler);
+        activeScheduler.start();
+    }
+}
+function stopPhaseDServices() {
+    activeWitness?.stop();
+    activeCheckpointMgr?.stop();
+    activeScheduler?.stop();
+    activeWitness = null;
+    activeDeacon = null;
+    activeDogs = null;
+    activeCheckpointMgr = null;
+    activeRefinery = null;
+    activeEscalation = null;
+    activeScheduler = null;
+    setActiveRefinery(null);
+    setActiveRouter(null);
+    setActiveScheduler(null);
+}
 // Input validation
 const VALID_TOPOLOGIES = new Set([
     'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive',
@@ -87,6 +196,8 @@ export const swarmTools = [
             const store = loadSwarmStore();
             store.swarms[swarmId] = swarmState;
             saveSwarmStore(store);
+            // Start Phase D services (watchdog, checkpoint, refinery, escalation, scheduler)
+            startPhaseDServices(config, maxAgents);
             return {
                 success: true,
                 swarmId,
@@ -96,6 +207,7 @@ export const swarmTools = [
                 initializedAt: now,
                 config: swarmState.config,
                 persisted: true,
+                watchdog: activeWitness?.isRunning() ? 'active' : 'disabled',
             };
         },
     },
@@ -112,6 +224,12 @@ export const swarmTools = [
         handler: async (input) => {
             const store = loadSwarmStore();
             const swarmId = input.swarmId;
+            const watchdogState = {
+                enabled: activeWitness !== null,
+                running: activeWitness?.isRunning() ?? false,
+                unresponsiveCounts: activeDeacon ? Object.fromEntries(activeDeacon.getUnresponsiveCounts()) : {},
+                events: activeDogs ? activeDogs.getEvents().slice(-10) : [],
+            };
             if (swarmId && store.swarms[swarmId]) {
                 const swarm = store.swarms[swarmId];
                 return {
@@ -124,6 +242,7 @@ export const swarmTools = [
                     config: swarm.config,
                     createdAt: swarm.createdAt,
                     updatedAt: swarm.updatedAt,
+                    watchdog: watchdogState,
                 };
             }
             // Return most recent swarm if no ID specified
@@ -149,6 +268,7 @@ export const swarmTools = [
                 createdAt: latest.createdAt,
                 updatedAt: latest.updatedAt,
                 totalSwarms: swarmIds.length,
+                watchdog: watchdogState,
             };
         },
     },
@@ -194,6 +314,8 @@ export const swarmTools = [
             target.status = 'terminated';
             target.updatedAt = new Date().toISOString();
             saveSwarmStore(store);
+            // Stop all Phase D services
+            stopPhaseDServices();
             return {
                 success: true,
                 swarmId: target.swarmId,

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

@@ -27,7 +27,7 @@ function getPackageVersion() {
 }
 const PKG_VERSION = getPackageVersion();
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
+const STORAGE_DIR = '.odd-flow';
 const SYSTEM_DIR = 'system';
 const METRICS_FILE = 'metrics.json';
 function getSystemDir() {
@@ -383,7 +383,7 @@ export const systemTools = [
         },
         handler: async () => {
             // Read from the task store file
-            const storePath = join(process.cwd(), '.claude-flow', 'tasks', 'store.json');
+            const storePath = join(process.cwd(), '.odd-flow', 'tasks', 'store.json');
             let tasks = [];
             try {
                 if (existsSync(storePath)) {

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

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
+const STORAGE_DIR = '.odd-flow';
 const TASK_DIR = 'tasks';
 const TASK_FILE = 'store.json';
 function getTaskDir() {

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

@@ -6,7 +6,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
+const STORAGE_DIR = '.odd-flow';
 const WORKFLOW_DIR = 'workflows';
 const WORKFLOW_FILE = 'store.json';
 function getWorkflowDir() {

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

@@ -18,15 +18,15 @@ import { join } from 'node:path';
 // ============================================================================
 /**
  * Get the data directory for neural pattern persistence
- * Uses .claude-flow/neural in the current working directory,
+ * Uses .odd-flow/neural in the current working directory,
  * falling back to home directory
  */
 function getDataDir() {
     const cwd = process.cwd();
-    const localDir = join(cwd, '.claude-flow', 'neural');
-    const homeDir = join(homedir(), '.claude-flow', 'neural');
-    // Prefer local directory if .claude-flow exists
-    if (existsSync(join(cwd, '.claude-flow'))) {
+    const localDir = join(cwd, '.odd-flow', 'neural');
+    const homeDir = join(homedir(), '.odd-flow', 'neural');
+    // Prefer local directory if .odd-flow exists
+    if (existsSync(join(cwd, '.odd-flow'))) {
         return localDir;
     }
     return homeDir;

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

@@ -49,7 +49,7 @@ function generateId(prefix) {
 }
 /**
  * Lazily initialize the ControllerRegistry singleton.
- * Returns null if @claude-flow/memory is not available.
+ * Returns null if @odd-flow/memory is not available.
  */
 async function getRegistry(dbPath) {
     if (bridgeAvailable === false)
@@ -59,7 +59,7 @@ async function getRegistry(dbPath) {
     if (!registryPromise) {
         registryPromise = (async () => {
             try {
-                const { ControllerRegistry } = await import('@claude-flow/memory');
+                const { ControllerRegistry } = await import('@odd-flow/memory');
                 const registry = new ControllerRegistry();
                 // Suppress noisy console.log during init
                 const origLog = console.log;

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

@@ -888,7 +888,7 @@ export async function checkAndMigrateLegacy(options) {
         path.join(process.cwd(), 'memory.db'),
         path.join(process.cwd(), '.claude/memory.db'),
         path.join(process.cwd(), 'data/memory.db'),
-        path.join(process.cwd(), '.claude-flow/memory.db')
+        path.join(process.cwd(), '.odd-flow/memory.db')
     ];
     for (const legacyPath of legacyPaths) {
         if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
@@ -931,7 +931,7 @@ export async function checkAndMigrateLegacy(options) {
  * a singleton ControllerRegistry and initializes it with the given dbPath.
  * After this call, all enabled controllers are ready for immediate use.
  *
- * Failures are isolated: if @claude-flow/memory or agentdb is not installed,
+ * Failures are isolated: if @odd-flow/memory or agentdb is not installed,
  * this returns an empty result without throwing.
  */
 async function activateControllerRegistry(dbPath, verbose) {
@@ -1698,7 +1698,7 @@ export async function storeEntry(options) {
     const dbPath = customPath ? path.resolve(customPath) : path.join(swarmDir, 'memory.db');
     try {
         if (!fs.existsSync(dbPath)) {
-            return { success: false, id: '', error: 'Database not initialized. Run: claude-flow memory init' };
+            return { success: false, id: '', error: 'Database not initialized. Run: odd-flow memory init' };
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);

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

@@ -33,7 +33,7 @@ export class PluginManager {
     config;
     manifest = null;
     constructor(baseDir = process.cwd()) {
-        const pluginsDir = path.join(baseDir, '.claude-flow', 'plugins');
+        const pluginsDir = path.join(baseDir, '.odd-flow', 'plugins');
         this.config = {
             pluginsDir,
             manifestPath: path.join(pluginsDir, 'installed.json'),
@@ -114,10 +114,10 @@ export class PluginManager {
             if (fs.existsSync(packageJsonPath)) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 installedVersion = pkg.version;
-                // Check for claude-flow plugin metadata
-                if (pkg['claude-flow']) {
-                    commands = pkg['claude-flow'].commands || [];
-                    hooks = pkg['claude-flow'].hooks || [];
+                // Check for odd-flow plugin metadata
+                if (pkg['odd-flow']) {
+                    commands = pkg['odd-flow'].commands || [];
+                    hooks = pkg['odd-flow'].hooks || [];
                 }
             }
             // Create plugin entry
@@ -177,8 +177,8 @@ export class PluginManager {
                 enabled: true,
                 source: 'local',
                 path: absolutePath,
-                commands: pkg['claude-flow']?.commands || [],
-                hooks: pkg['claude-flow']?.hooks || [],
+                commands: pkg['odd-flow']?.commands || [],
+                hooks: pkg['odd-flow']?.hooks || [],
             };
             // Save to manifest
             this.manifest.plugins[packageName] = plugin;
@@ -338,8 +338,8 @@ export class PluginManager {
             if (fs.existsSync(packageJsonPath)) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 existing.version = pkg.version;
-                existing.commands = pkg['claude-flow']?.commands || existing.commands;
-                existing.hooks = pkg['claude-flow']?.hooks || existing.hooks;
+                existing.commands = pkg['odd-flow']?.commands || existing.commands;
+                existing.hooks = pkg['odd-flow']?.hooks || existing.hooks;
             }
             await this.saveManifest();
             console.log(`[PluginManager] Upgraded ${packageName} to ${existing.version}`);
@@ -389,7 +389,7 @@ export function getPluginManager(baseDir) {
     if (!defaultManager) {
         defaultManager = new PluginManager(baseDir);
     }
-    else if (baseDir && defaultManager.getPluginsDir() !== path.join(baseDir, '.claude-flow', 'plugins')) {
+    else if (baseDir && defaultManager.getPluginsDir() !== path.join(baseDir, '.odd-flow', 'plugins')) {
         console.warn(`[PluginManager] Warning: getPluginManager called with different baseDir. Using existing instance. Call resetPluginManager() first to change.`);
     }
     return defaultManager;