@claude-flow/cli 3.22.0 → 3.24.0

package/dist/src/services/memory-backup.js

@@ -0,0 +1,94 @@
+/**
+ * Vector-memory DB backup.
+ *
+ * Snapshots `.swarm/memory.db` (the sqlite store holding memory_entries +
+ * embeddings + the distilled reasoning_patterns) to a timestamped file using
+ * better-sqlite3's ONLINE backup API — a consistent, WAL-safe copy that does not
+ * block or corrupt a concurrently-written DB (unlike a naive file copy of a
+ * WAL-mode DB). Rotates to keep the last N snapshots and, optionally, uploads
+ * offsite to Google Cloud Storage.
+ *
+ * Used by `memory backup` (manual) and the daemon's nightly `backup` worker.
+ * Best-effort + non-destructive: it only reads the source DB and writes new
+ * files; it never mutates or deletes the live memory DB.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export function defaultMemoryDbPath(cwd = process.cwd()) {
+    return path.join(cwd, '.swarm', 'memory.db');
+}
+/** ISO timestamp safe for filenames (no ':' or '.'). */
+function fileStamp(ms) {
+    return new Date(ms).toISOString().replace(/[:.]/g, '-');
+}
+export async function backupMemoryDb(opts = {}) {
+    const dbPath = opts.dbPath ?? defaultMemoryDbPath();
+    if (!dbPath || !fs.existsSync(dbPath))
+        return { backedUp: false, skipped: 'no-db' };
+    let Database;
+    try {
+        const mod = 'better-sqlite3';
+        Database = (await import(mod)).default;
+    }
+    catch {
+        return { backedUp: false, skipped: 'better-sqlite3 unavailable' };
+    }
+    const destDir = opts.destDir ?? path.join(path.dirname(dbPath), 'backups');
+    try {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    catch { /* */ }
+    const destPath = path.join(destDir, `memory-${fileStamp(opts.timestamp ?? Date.now())}.db`);
+    // WAL-safe online backup: read-only source, consistent snapshot to destPath.
+    let db;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        await db.backup(destPath);
+        db.close();
+    }
+    catch (e) {
+        try {
+            db?.close();
+        }
+        catch { /* */ }
+        return { backedUp: false, skipped: `backup failed: ${e?.message ?? e}` };
+    }
+    let sizeBytes = 0;
+    try {
+        sizeBytes = fs.statSync(destPath).size;
+    }
+    catch { /* */ }
+    // Rotation — ISO-stamped names sort chronologically, so keep the tail.
+    const keep = typeof opts.keep === 'number' && opts.keep > 0 ? opts.keep : 7;
+    const rotatedAway = [];
+    try {
+        const snaps = fs.readdirSync(destDir).filter(f => /^memory-.*\.db$/.test(f)).sort();
+        while (snaps.length > keep) {
+            const old = snaps.shift();
+            try {
+                fs.rmSync(path.join(destDir, old), { force: true });
+                rotatedAway.push(old);
+            }
+            catch { /* */ }
+        }
+    }
+    catch { /* */ }
+    // Optional offsite to GCS (best-effort; local backup already succeeded).
+    let gcsUri;
+    if (opts.gcs) {
+        try {
+            const { execFileSync } = await import('child_process');
+            const dest = opts.gcs.replace(/\/+$/, '') + '/' + path.basename(destPath);
+            execFileSync('gcloud', ['storage', 'cp', destPath, dest], { stdio: ['ignore', 'ignore', 'inherit'] });
+            gcsUri = dest;
+        }
+        catch { /* offsite failed — local snapshot stands */ }
+    }
+    if (opts.verbose) {
+        console.log(`memory DB backed up → ${destPath} (${Math.round(sizeBytes / 1024)} KB)` +
+            (rotatedAway.length ? `, rotated ${rotatedAway.length} old` : '') +
+            (gcsUri ? `, offsite ${gcsUri}` : ''));
+    }
+    return { backedUp: true, path: destPath, sizeBytes, rotatedAway, gcsUri };
+}
+//# sourceMappingURL=memory-backup.js.map

package/dist/src/services/worker-daemon.d.ts

@@ -12,7 +12,7 @@
  */
 import { EventEmitter } from 'events';
 import { HeadlessWorkerExecutor } from './headless-worker-executor.js';
-export type WorkerType = 'ultralearn' | 'optimize' | 'consolidate' | 'predict' | 'audit' | 'map' | 'preload' | 'deepdive' | 'document' | 'refactor' | 'benchmark' | 'testgaps';
+export type WorkerType = 'ultralearn' | 'optimize' | 'consolidate' | 'predict' | 'audit' | 'map' | 'preload' | 'deepdive' | 'document' | 'refactor' | 'benchmark' | 'testgaps' | 'backup' | 'harness';
 interface WorkerConfig {
     type: WorkerType;
     intervalMs: number;
@@ -319,6 +319,21 @@ export declare class WorkerDaemon extends EventEmitter {
      *    call defensively — a background worker must never crash the daemon.
      */
     private runConsolidateWorker;
+    /**
+     * 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.
+     */
+    private runBackupWorker;
+    /**
+     * 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.
+     */
+    private runHarnessWorker;
     /**
      * Local testgaps worker (fallback when headless unavailable)
      */

package/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/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",