claude-flow 3.22.0 → 3.24.0

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

@@ -21,6 +21,7 @@ import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-exe
 // incremental (rowid cursor), non-destructive, transactional, and
 // quick_check-gated, so it's safe to call unconditionally on every tick.
 import { runDistillation, defaultMemoryDbPath } from './memory-distillation.js';
+import { backupMemoryDb } from './memory-backup.js';
 // Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
 const DEFAULT_WORKERS = [
     { type: 'map', intervalMs: 15 * 60 * 1000, offsetMs: 0, priority: 'normal', description: 'Codebase mapping', enabled: true },
@@ -28,6 +29,8 @@ const DEFAULT_WORKERS = [
     { type: 'optimize', intervalMs: 15 * 60 * 1000, offsetMs: 4 * 60 * 1000, priority: 'high', description: 'Performance optimization', enabled: true },
     { type: 'consolidate', intervalMs: 30 * 60 * 1000, offsetMs: 6 * 60 * 1000, priority: 'low', description: 'Memory distillation (ADR-174)', enabled: true },
     { type: 'testgaps', intervalMs: 20 * 60 * 1000, offsetMs: 8 * 60 * 1000, priority: 'normal', description: 'Test coverage analysis', enabled: true },
+    { type: 'backup', intervalMs: 24 * 60 * 60 * 1000, offsetMs: 10 * 60 * 1000, priority: 'low', description: 'Nightly memory DB backup (WAL-safe, rotated)', enabled: true },
+    { type: 'harness', intervalMs: 6 * 60 * 60 * 1000, offsetMs: 12 * 60 * 1000, priority: 'low', description: 'Self-optimizing harness loop (opt-in RUFLO_HARNESS_LOOP, $0-default)', enabled: true },
     { type: 'predict', intervalMs: 10 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Predictive preloading', enabled: false },
     { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
 ];
@@ -1158,6 +1161,10 @@ export class WorkerDaemon extends EventEmitter {
                 return this.runOptimizeWorkerLocal();
             case 'consolidate':
                 return this.runConsolidateWorker();
+            case 'backup':
+                return this.runBackupWorker();
+            case 'harness':
+                return this.runHarnessWorker();
             case 'testgaps':
                 return this.runTestGapsWorkerLocal();
             case 'predict':
@@ -1395,6 +1402,83 @@ export class WorkerDaemon extends EventEmitter {
         writeFileSync(consolidateFile, JSON.stringify(result, null, 2));
         return result;
     }
+    /**
+     * Nightly memory-DB backup worker (24h interval). Takes a WAL-safe, consistent
+     * snapshot of .swarm/memory.db with rotation (keep last N). Never throws — a
+     * worker must not crash the daemon; a skip/error is written to the metrics
+     * file. Opt-out by omitting `backup` from `-w`; offsite GCS is opt-in via
+     * RUFLO_BACKUP_GCS (a gs:// prefix), retention via RUFLO_BACKUP_KEEP.
+     */
+    async runBackupWorker() {
+        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+        if (!existsSync(metricsDir))
+            mkdirSync(metricsDir, { recursive: true });
+        const backupFile = join(metricsDir, 'backup.json');
+        let result;
+        try {
+            const keepEnv = Number(process.env.RUFLO_BACKUP_KEEP);
+            const r = await backupMemoryDb({
+                dbPath: defaultMemoryDbPath(this.projectRoot),
+                keep: Number.isFinite(keepEnv) && keepEnv > 0 ? keepEnv : 7,
+                gcs: process.env.RUFLO_BACKUP_GCS || undefined,
+            });
+            result = {
+                timestamp: new Date().toISOString(),
+                backedUp: r.backedUp,
+                path: r.path,
+                sizeBytes: r.sizeBytes ?? 0,
+                rotatedAway: r.rotatedAway?.length ?? 0,
+                gcsUri: r.gcsUri,
+                skipped: r.skipped,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log('warn', `Backup worker failed: ${message}`);
+            result = { timestamp: new Date().toISOString(), backedUp: false, error: message };
+        }
+        writeFileSync(backupFile, JSON.stringify(result, null, 2));
+        return result;
+    }
+    /**
+     * Self-optimizing harness loop worker (ADR-176 phase 8). Strictly bounded:
+     * OPT-IN (RUFLO_HARNESS_LOOP), $0-default (no optimizer/verifier wired => no
+     * promotion), trajectory-capped, single-flight via the daemon, never throws.
+     * On acceptance the (unsigned) champion is staged for the separate sign step.
+     */
+    async runHarnessWorker() {
+        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+        if (!existsSync(metricsDir))
+            mkdirSync(metricsDir, { recursive: true });
+        const harnessFile = join(metricsDir, 'harness-loop.json');
+        let result;
+        try {
+            // ADR-176 flywheel (A-P3b autonomy loop): run ONE COMPOUNDING generation
+            // on the install's REAL data — read the persisted champion as baseline,
+            // gate a constrained candidate on the frozen self-supervised held-out with
+            // the human-anchor guard + separate canary, and on a verified promotion
+            // advance the champion so the NEXT tick compounds. Shadow-first (serve lags
+            // one tick). Opt-in ($0 no-op without RUFLO_HARNESS_LOOP).
+            const { runFlywheelGenerationWorker } = await import('./harness-flywheel-runtime.js');
+            const gen = await runFlywheelGenerationWorker(this.projectRoot, { sample: 120 });
+            let status = null;
+            try {
+                const { flywheelStatus } = await import('./harness-flywheel-generations.js');
+                status = flywheelStatus(this.projectRoot);
+            }
+            catch { /* no lineage yet */ }
+            if (gen.promoted)
+                this.log('info', `Flywheel gen ${gen.generation}: PROMOTED (+${(gen.delta ?? 0).toFixed(4)} held-out, significant=${gen.significant}) — champion advanced`);
+            result = { timestamp: new Date().toISOString(), flywheel: gen, lineage: status };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log('warn', `Harness worker failed: ${message}`);
+            result = { timestamp: new Date().toISOString(), ran: false, error: message };
+        }
+        writeFileSync(harnessFile, JSON.stringify(result, null, 2));
+        return result;
+    }
     /**
      * Local testgaps worker (fallback when headless unavailable)
      */

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.22.0",
+  "version": "3.24.0",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",