claude-flow 3.22.0 → 3.24.0

package/v3/@claude-flow/cli/dist/src/services/harness-qualification.d.ts

@@ -0,0 +1,66 @@
+export type ProvenanceTier = 'oracle:test-exec' | 'judge:fable' | 'proxy:structural';
+export interface TrajectoryStep {
+    action: string;
+    tier: ProvenanceTier;
+}
+export interface Trajectory {
+    id: string;
+    steps: TrajectoryStep[];
+    outcome: 'success' | 'failure';
+    benchmarkTaskId?: string;
+    inputs: unknown;
+    recordedOutputs: unknown;
+}
+/** Re-execute a trajectory's recorded inputs and return the outputs. */
+export type ReplayFn = (t: Trajectory) => unknown;
+export interface QualificationResult {
+    qualified: boolean;
+    reasons: string[];
+}
+/** Fingerprint a trajectory by its shape (step actions + outcome) so identical failures dedupe. */
+export declare function fingerprintTrajectory(t: Trajectory): string;
+/**
+ * Invariant Q. `replay` is required — determinism cannot be asserted without
+ * re-executing; a trajectory with no verifiable replay is REJECTED (fail-closed).
+ */
+export declare function qualifyTrajectory(t: Trajectory, replay?: ReplayFn): QualificationResult;
+export interface AntiPattern {
+    fingerprint: string;
+    stage: string;
+    reasons: string[];
+    ts: number;
+}
+/**
+ * File-backed avoid-list of rejected trajectories/mutations. JSONL, append-only
+ * with a bounded cap: once the file exceeds `maxEntries` it is rewritten to the
+ * newest `maxEntries` (rotation), so the archive can never grow unbounded —
+ * runaway-storage guard. Deduped by fingerprint at the call site.
+ */
+export declare class AntiPatternArchive {
+    private readonly filePath;
+    private readonly maxEntries;
+    constructor(filePath: string, maxEntries?: number);
+    private load;
+    record(entry: AntiPattern): void;
+    has(fingerprint: string): boolean;
+    list(): AntiPattern[];
+}
+export interface AdmissionReport {
+    qualified: Trajectory[];
+    rejected: Array<{
+        id: string;
+        reasons: string[];
+    }>;
+    admittedCount: number;
+    rejectedCount: number;
+}
+/**
+ * Admit a batch of observed trajectories into the candidate dataset. Rejects are
+ * recorded to the anti-pattern archive (deduped by fingerprint).
+ */
+export declare function admitTrajectories(trajectories: Trajectory[], opts?: {
+    replay?: ReplayFn;
+    archive?: AntiPatternArchive;
+    ts?: number;
+}): AdmissionReport;
+//# sourceMappingURL=harness-qualification.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/harness-qualification.js

@@ -0,0 +1,143 @@
+/**
+ * Qualification + anti-pattern archive (ADR-176 phase 1).
+ *
+ * Separates OBSERVATION from TRAINING DATA. Raw observed trajectories are NOT
+ * training data — they enter optimization only through the Qualification gate,
+ * which enforces:
+ *
+ *   Invariant Q: a trajectory is admitted iff it has
+ *     (a) complete provenance   — every step attributed, tier >= oracle/judge
+ *                                  (ADR-171; proxy:structural is triage-only),
+ *     (b) deterministic replay   — re-running its recorded inputs reproduces its
+ *                                  recorded outputs, and
+ *     (c) benchmark attribution  — it maps to a task in the versioned corpus.
+ *
+ * Rejected trajectories are not discarded — they are recorded to the
+ * ANTI-PATTERN ARCHIVE (negative learning), so future optimization runs avoid
+ * re-discovering identical failures. Zero dependencies, $0.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'crypto';
+/** Deterministic JSON for the replay comparison (recursively key-sorted). */
+function stable(v) {
+    const c = (x) => {
+        if (Array.isArray(x))
+            return x.map(c);
+        if (x && typeof x === 'object') {
+            const o = {};
+            for (const k of Object.keys(x).sort())
+                o[k] = c(x[k]);
+            return o;
+        }
+        return x;
+    };
+    return JSON.stringify(c(v));
+}
+/** Fingerprint a trajectory by its shape (step actions + outcome) so identical failures dedupe. */
+export function fingerprintTrajectory(t) {
+    const shape = t.steps.map(s => s.action).join('→') + '#' + t.outcome + '#' + (t.benchmarkTaskId ?? '');
+    return createHash('sha256').update(shape).digest('hex').slice(0, 32);
+}
+/**
+ * Invariant Q. `replay` is required — determinism cannot be asserted without
+ * re-executing; a trajectory with no verifiable replay is REJECTED (fail-closed).
+ */
+export function qualifyTrajectory(t, replay) {
+    const reasons = [];
+    // (a) complete provenance
+    if (!t.steps || t.steps.length === 0)
+        reasons.push('incomplete: no steps');
+    else {
+        if (t.steps.some(s => !s.action))
+            reasons.push('incomplete provenance: a step has no action');
+        if (t.steps.some(s => s.tier === 'proxy:structural'))
+            reasons.push('proxy-tier step present (below oracle/judge; ADR-171)');
+    }
+    // (c) benchmark attribution
+    if (!t.benchmarkTaskId)
+        reasons.push('no benchmark attribution');
+    // (b) deterministic replay
+    if (!replay) {
+        reasons.push('deterministic replay not verified (no replay fn)');
+    }
+    else {
+        let out;
+        try {
+            out = replay(t);
+        }
+        catch (e) {
+            reasons.push(`replay threw: ${e?.message ?? e}`);
+            out = undefined;
+        }
+        if (reasons.every(r => !r.startsWith('replay threw')) && stable(out) !== stable(t.recordedOutputs)) {
+            reasons.push('replay non-deterministic (outputs differ from recorded)');
+        }
+    }
+    return { qualified: reasons.length === 0, reasons };
+}
+/**
+ * File-backed avoid-list of rejected trajectories/mutations. JSONL, append-only
+ * with a bounded cap: once the file exceeds `maxEntries` it is rewritten to the
+ * newest `maxEntries` (rotation), so the archive can never grow unbounded —
+ * runaway-storage guard. Deduped by fingerprint at the call site.
+ */
+export class AntiPatternArchive {
+    filePath;
+    maxEntries;
+    constructor(filePath, maxEntries = 10000) {
+        this.filePath = filePath;
+        this.maxEntries = maxEntries;
+    }
+    load() {
+        try {
+            return fs.readFileSync(this.filePath, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
+        }
+        catch {
+            return [];
+        }
+    }
+    record(entry) {
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            const existing = this.load();
+            if (existing.length >= this.maxEntries) {
+                // Rotate: keep the newest (maxEntries-1) + the new entry.
+                const kept = existing.slice(existing.length - (this.maxEntries - 1));
+                fs.writeFileSync(this.filePath, kept.concat(entry).map(e => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+            }
+            else {
+                fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n', 'utf-8');
+            }
+        }
+        catch { /* best-effort */ }
+    }
+    has(fingerprint) {
+        return this.load().some(a => a.fingerprint === fingerprint);
+    }
+    list() { return this.load(); }
+}
+/**
+ * Admit a batch of observed trajectories into the candidate dataset. Rejects are
+ * recorded to the anti-pattern archive (deduped by fingerprint).
+ */
+export function admitTrajectories(trajectories, opts = {}) {
+    const qualified = [];
+    const rejected = [];
+    const ts = opts.ts ?? Date.now();
+    for (const t of trajectories) {
+        const r = qualifyTrajectory(t, opts.replay);
+        if (r.qualified) {
+            qualified.push(t);
+        }
+        else {
+            rejected.push({ id: t.id, reasons: r.reasons });
+            const fp = fingerprintTrajectory(t);
+            if (opts.archive && !opts.archive.has(fp)) {
+                opts.archive.record({ fingerprint: fp, stage: 'qualification', reasons: r.reasons, ts });
+            }
+        }
+    }
+    return { qualified, rejected, admittedCount: qualified.length, rejectedCount: rejected.length };
+}
+//# sourceMappingURL=harness-qualification.js.map

package/v3/@claude-flow/cli/dist/src/services/harness-replay.d.ts

@@ -0,0 +1,37 @@
+/** Content digest of a value (canonical, order-independent). */
+export declare function digest(v: unknown): string;
+export interface RecordedRun {
+    id: string;
+    inputs: unknown;
+    outputDigest: string;
+    recordedAt?: number;
+}
+/** Re-executable unit: given inputs, produce outputs. Must be pure for determinism. */
+export type RunFn = (inputs: unknown) => unknown;
+/** Capture a run: execute once and record the output digest. */
+export declare function recordRun(id: string, inputs: unknown, run: RunFn, ts?: number): RecordedRun;
+export interface ReplayResult {
+    deterministic: boolean;
+    expectedDigest: string;
+    actualDigest: string;
+}
+/** Replay a recorded run and check it reproduces the recorded output digest. */
+export declare function verifyReplay(recorded: RecordedRun, run: RunFn): ReplayResult;
+/** Batch predicate for accept(): all recorded runs replay deterministically. */
+export declare function allDeterministic(recorded: RecordedRun[], run: RunFn): boolean;
+/**
+ * File-backed store of recorded runs (JSONL). Append-only with a bounded cap:
+ * once it exceeds `maxEntries` it rotates to the newest `maxEntries` — so the
+ * store can never grow unbounded (runaway-storage guard). `get` returns the
+ * latest for an id.
+ */
+export declare class ReplayStore {
+    private readonly filePath;
+    private readonly maxEntries;
+    constructor(filePath: string, maxEntries?: number);
+    private load;
+    record(r: RecordedRun): void;
+    get(id: string): RecordedRun | undefined;
+    all(): RecordedRun[];
+}
+//# sourceMappingURL=harness-replay.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/harness-replay.js

@@ -0,0 +1,92 @@
+/**
+ * Deterministic replay engine (ADR-176 phase 3).
+ *
+ * The `replay == deterministic` predicate in Invariant Q (qualification) and in
+ * accept() requires re-executing a recorded run's inputs and confirming they
+ * reproduce the recorded outputs. This module records an output DIGEST at
+ * capture time and verifies a replay reproduces it — so a trajectory only
+ * counts as training data / promotion evidence if its behavior is reproducible.
+ * Zero deps, $0.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'crypto';
+function stable(v) {
+    const c = (x) => {
+        if (Array.isArray(x))
+            return x.map(c);
+        if (x && typeof x === 'object') {
+            const o = {};
+            for (const k of Object.keys(x).sort())
+                o[k] = c(x[k]);
+            return o;
+        }
+        return x;
+    };
+    return JSON.stringify(c(v));
+}
+/** Content digest of a value (canonical, order-independent). */
+export function digest(v) {
+    return createHash('sha256').update(stable(v)).digest('hex');
+}
+/** Capture a run: execute once and record the output digest. */
+export function recordRun(id, inputs, run, ts) {
+    return { id, inputs, outputDigest: digest(run(inputs)), recordedAt: ts };
+}
+/** Replay a recorded run and check it reproduces the recorded output digest. */
+export function verifyReplay(recorded, run) {
+    let actual;
+    try {
+        actual = digest(run(recorded.inputs));
+    }
+    catch {
+        actual = 'THREW';
+    }
+    return { deterministic: actual === recorded.outputDigest, expectedDigest: recorded.outputDigest, actualDigest: actual };
+}
+/** Batch predicate for accept(): all recorded runs replay deterministically. */
+export function allDeterministic(recorded, run) {
+    return recorded.every(r => verifyReplay(r, run).deterministic);
+}
+/**
+ * File-backed store of recorded runs (JSONL). Append-only with a bounded cap:
+ * once it exceeds `maxEntries` it rotates to the newest `maxEntries` — so the
+ * store can never grow unbounded (runaway-storage guard). `get` returns the
+ * latest for an id.
+ */
+export class ReplayStore {
+    filePath;
+    maxEntries;
+    constructor(filePath, maxEntries = 10000) {
+        this.filePath = filePath;
+        this.maxEntries = maxEntries;
+    }
+    load() {
+        try {
+            return fs.readFileSync(this.filePath, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
+        }
+        catch {
+            return [];
+        }
+    }
+    record(r) {
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+            const existing = this.load();
+            if (existing.length >= this.maxEntries) {
+                const kept = existing.slice(existing.length - (this.maxEntries - 1));
+                fs.writeFileSync(this.filePath, kept.concat(r).map(e => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+            }
+            else {
+                fs.appendFileSync(this.filePath, JSON.stringify(r) + '\n', 'utf-8');
+            }
+        }
+        catch { /* best-effort */ }
+    }
+    get(id) {
+        const all = this.load().filter(r => r.id === id);
+        return all.length ? all[all.length - 1] : undefined; // latest wins
+    }
+    all() { return this.load(); }
+}
+//# sourceMappingURL=harness-replay.js.map

package/v3/@claude-flow/cli/dist/src/services/harness-verify.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Adversarial + drift verify gate (ADR-176 phase 4).
+ *
+ * Produces the two verdicts accept() consumes beyond held-out benchmarking:
+ *   - redblue: an adversarial red-team pass (@metaharness/redblue, mock-judge/$0
+ *     by default, loopback-only, cost-capped),
+ *   - drift:   distance from the current champion (@metaharness/drift_from_history).
+ *
+ * FAIL-CLOSED: if the adversarial verifier is unavailable (metaharness is an
+ * optional dependency — ADR-150), redblue is SKIPPED, and since accept() requires
+ * redblue === 'PASS', a candidate CANNOT be promoted without real adversarial
+ * evidence. The loop then safely degrades to "observe + benchmark, don't
+ * promote" and the current signed champion stands. Runners are injectable so the
+ * orchestrator supplies the real metaharness bridge; defaults degrade. $0.
+ */
+export type RedblueVerdict = 'PASS' | 'FAIL' | 'SKIPPED';
+export type RedblueRunner = () => Promise<RedblueVerdict>;
+/** Returns the drift distance from the champion (>=0), or a negative value = unavailable. */
+export type DriftRunner = () => Promise<number>;
+export interface VerifyResult {
+    redblue: RedblueVerdict;
+    drift: number;
+    driftThreshold: number;
+    driftVerdict: 'ok' | 'regressed' | 'skipped';
+    adversarialPass: boolean;
+}
+export interface VerifyOptions {
+    redblue?: RedblueRunner;
+    drift?: DriftRunner;
+    driftThreshold?: number;
+}
+export declare function runVerify(opts?: VerifyOptions): Promise<VerifyResult>;
+//# sourceMappingURL=harness-verify.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/harness-verify.js

@@ -0,0 +1,26 @@
+/** Default redblue: no verifier wired in this module → SKIPPED (fail-closed). */
+const defaultRedblue = async () => 'SKIPPED';
+/** Default drift: no baseline → 0. */
+const defaultDrift = async () => 0;
+export async function runVerify(opts = {}) {
+    const driftThreshold = opts.driftThreshold ?? 0.05;
+    let redblue;
+    try {
+        redblue = await (opts.redblue ?? defaultRedblue)();
+    }
+    catch {
+        redblue = 'SKIPPED';
+    } // a throwing verifier is not a PASS
+    let drift;
+    try {
+        drift = await (opts.drift ?? defaultDrift)();
+    }
+    catch {
+        drift = -1;
+    }
+    const driftVerdict = drift < 0 ? 'skipped' : (drift <= driftThreshold ? 'ok' : 'regressed');
+    // Fail-closed: promotion requires a real PASS and a non-regressing, non-skipped drift.
+    const adversarialPass = redblue === 'PASS' && driftVerdict === 'ok';
+    return { redblue, drift, driftThreshold, driftVerdict, adversarialPass };
+}
+//# sourceMappingURL=harness-verify.js.map

package/v3/@claude-flow/cli/dist/src/services/harness-worker.d.ts

@@ -0,0 +1,23 @@
+import { type HarnessLoopOptions } from './harness-loop.js';
+export declare const STAGED_CHAMPION_FILE = "harness-champion.manifest.json";
+export type HarnessWorkerInput = HarnessLoopOptions<any>;
+export type LoadHarnessInput = (projectRoot: string) => HarnessWorkerInput | null;
+export interface HarnessWorkerResult {
+    ran: boolean;
+    reason: string;
+    accepted?: boolean;
+    staged?: boolean;
+    admitted?: number;
+    rejected?: number;
+}
+export declare function harnessLoopOptedIn(): boolean;
+/**
+ * Execute one bounded, opt-in harness-loop tick for `projectRoot`. Injectable
+ * `loadInput`/`optInOverride` for tests. Best-effort; never throws.
+ */
+export declare function runHarnessLoopWorker(projectRoot: string, opts?: {
+    loadInput?: LoadHarnessInput;
+    maxTrajectories?: number;
+    optInOverride?: boolean;
+}): Promise<HarnessWorkerResult>;
+//# sourceMappingURL=harness-worker.d.ts.map

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

@@ -0,0 +1,66 @@
+/**
+ * Harness loop daemon worker (ADR-176 phase 8, part 2).
+ *
+ * Runs runHarnessLoop() on the daemon's schedule — but strictly bounded, given
+ * the runaway-resource posture:
+ *   - OPT-IN: no-op unless RUFLO_HARNESS_LOOP is truthy. The self-optimizing
+ *     loop never runs autonomously without an explicit opt-in.
+ *   - $0: with no optimizer/verifier/canary wired (the default), runHarnessLoop
+ *     qualifies + benchmarks but promotes nothing (fail-closed). No LLM, no
+ *     metaharness subprocess, no spend unless the operator opts those in too.
+ *   - bounded: trajectories capped per tick; the daemon adds single-flight
+ *     (maxConcurrent) + a 16-min worker timeout + TTL/idle shutdown.
+ *   - never throws: a worker must not crash the daemon.
+ *
+ * On acceptance it STAGES the (unsigned) champion manifest for the separate
+ * publish/sign step — the worker never signs (no key material in the daemon).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { runHarnessLoop } from './harness-loop.js';
+export const STAGED_CHAMPION_FILE = 'harness-champion.manifest.json';
+/** No built-in input source yet — the operator wires a corpus + optimizer. */
+const defaultLoadInput = () => null;
+export function harnessLoopOptedIn() {
+    return /^(1|true|yes|on)$/i.test(process.env.RUFLO_HARNESS_LOOP ?? '');
+}
+/**
+ * Execute one bounded, opt-in harness-loop tick for `projectRoot`. Injectable
+ * `loadInput`/`optInOverride` for tests. Best-effort; never throws.
+ */
+export async function runHarnessLoopWorker(projectRoot, opts = {}) {
+    try {
+        const optedIn = opts.optInOverride ?? harnessLoopOptedIn();
+        if (!optedIn)
+            return { ran: false, reason: 'opt-in required (RUFLO_HARNESS_LOOP=1)' };
+        const input = (opts.loadInput ?? defaultLoadInput)(projectRoot);
+        if (!input)
+            return { ran: false, reason: 'no harness input (corpus/optimizer) configured' };
+        const cap = opts.maxTrajectories ?? 2000;
+        const bounded = { ...input, trajectories: input.trajectories.slice(0, cap) };
+        const result = await runHarnessLoop(bounded);
+        let staged = false;
+        if (result.accepted && result.manifest) {
+            // Stage the UNSIGNED champion for the separate publish/sign step.
+            try {
+                const dir = path.join(projectRoot, '.claude-flow');
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(path.join(dir, STAGED_CHAMPION_FILE), JSON.stringify(result.manifest, null, 2), 'utf-8');
+                staged = true;
+            }
+            catch { /* non-fatal */ }
+        }
+        return {
+            ran: true,
+            reason: result.reason,
+            accepted: result.accepted,
+            staged,
+            admitted: result.admitted,
+            rejected: result.rejected,
+        };
+    }
+    catch (e) {
+        return { ran: false, reason: `error: ${e?.message ?? e}` };
+    }
+}
+//# sourceMappingURL=harness-worker.js.map

package/v3/@claude-flow/cli/dist/src/services/memory-backup.d.ts

@@ -0,0 +1,24 @@
+export interface BackupOptions {
+    /** Source DB (default: <cwd>/.swarm/memory.db). */
+    dbPath?: string;
+    /** Destination dir (default: <db dir>/backups). */
+    destDir?: string;
+    /** Rotation: keep the newest N snapshots (default 7 = a week of nightlies). */
+    keep?: number;
+    /** Optional offsite: a gs://bucket/prefix to also upload the snapshot to. */
+    gcs?: string;
+    /** Injected epoch millis (tests pass a fixed value; avoids Date.now in logic). */
+    timestamp?: number;
+    verbose?: boolean;
+}
+export interface BackupResult {
+    backedUp: boolean;
+    path?: string;
+    sizeBytes?: number;
+    rotatedAway?: string[];
+    gcsUri?: string;
+    skipped?: string;
+}
+export declare function defaultMemoryDbPath(cwd?: string): string;
+export declare function backupMemoryDb(opts?: BackupOptions): Promise<BackupResult>;
+//# sourceMappingURL=memory-backup.d.ts.map

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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)
      */