claude-flow 3.23.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/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' | 'backup';
+export type WorkerType = 'ultralearn' | 'optimize' | 'consolidate' | 'predict' | 'audit' | 'map' | 'preload' | 'deepdive' | 'document' | 'refactor' | 'benchmark' | 'testgaps' | 'backup' | 'harness';
 interface WorkerConfig {
     type: WorkerType;
     intervalMs: number;
@@ -327,6 +327,13 @@ export declare class WorkerDaemon extends EventEmitter {
      * 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/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -30,6 +30,7 @@ const DEFAULT_WORKERS = [
     { 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 },
 ];
@@ -1162,6 +1163,8 @@ export class WorkerDaemon extends EventEmitter {
                 return this.runConsolidateWorker();
             case 'backup':
                 return this.runBackupWorker();
+            case 'harness':
+                return this.runHarnessWorker();
             case 'testgaps':
                 return this.runTestGapsWorkerLocal();
             case 'predict':
@@ -1437,6 +1440,45 @@ export class WorkerDaemon extends EventEmitter {
         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.23.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",