claude-flow 3.14.4 → 3.15.0

package/.claude/settings.local.json

@@ -4,7 +4,8 @@
       "Bash(mkdir -p /tmp/ruflo-smoke)",
       "Bash(rm -rf /tmp/ruflo-smoke/*)",
       "Read(//tmp/**)",
-      "Bash(npm pack *)"
+      "Bash(npm pack *)",
+      "WebFetch(domain:www.npmjs.com)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.14.4",
+  "version": "3.15.0",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/commands/metaharness.js

@@ -56,6 +56,9 @@ const SUBCOMMANDS = {
     // iter 53 — one-command drift detection (compose audit-list + oia-audit + audit-trend)
     'drift-from-history': 'drift-from-history.mjs',
     mint: 'mint.mjs',
+    // @metaharness/redblue@~0.1.1 — adversarial red/blue LLM testing
+    // (init|run|patch|attack|report sub-subcommands handled by redblue.mjs)
+    redblue: 'redblue.mjs',
 };
 /**
  * Walk up from the current dirname to find the ruflo repo root that
@@ -63,8 +66,16 @@ const SUBCOMMANDS = {
  *   1. ruflo dev tree   (cwd / ../plugins/...)
  *   2. ruflo wrapper    (ruflo/node_modules/@claude-flow/cli/...)
  *   3. npx              (npm-cache/__npx/... — fall back to cwd-scan)
+ *
+ * `requiredScript`, if provided, narrows the match: the returned dir must
+ * contain BOTH `_harness.mjs` (proves it's a plugin-scripts dir) AND the
+ * named script. This guards against the publish-artifact mirror at
+ * `v3/@claude-flow/cli/plugins/ruflo-metaharness/scripts/` getting picked
+ * over the source `plugins/ruflo-metaharness/scripts/` when the mirror
+ * lags the source (the mirror is regenerated only at publish time by
+ * `prepublishOnly`).
  */
-function locatePluginScripts() {
+function locatePluginScripts(requiredScript) {
     const candidates = [];
     // Up from the cli dist dir
     let p = resolve(__dirname);
@@ -80,8 +91,11 @@ function locatePluginScripts() {
     candidates.push(join(cwd, 'plugins', 'ruflo-metaharness', 'scripts'));
     candidates.push(join(cwd, 'node_modules', '@claude-flow', 'cli', 'plugins', 'ruflo-metaharness', 'scripts'));
     for (const c of candidates) {
-        if (existsSync(join(c, '_harness.mjs')))
-            return c;
+        if (!existsSync(join(c, '_harness.mjs')))
+            continue;
+        if (requiredScript && !existsSync(join(c, requiredScript)))
+            continue;
+        return c;
     }
     return null;
 }
@@ -107,7 +121,7 @@ export const metaharnessCommand = {
             // iter 73 — list reflects all 10 dispatchable subcommands (was
             // stale at the iter-3 list of 5). Keep this synced with the
             // SUBCOMMANDS map above.
-            description: 'One of: score | genome | mcp-scan | threat-model | oia-audit | audit-list | audit-trend | similarity | drift-from-history | mint',
+            description: 'One of: score | genome | mcp-scan | threat-model | oia-audit | audit-list | audit-trend | similarity | drift-from-history | mint | redblue',
             type: 'string',
         },
     ],
@@ -169,6 +183,7 @@ export const metaharnessCommand = {
             output.writeln('  similarity    ADR-152 — weighted similarity between two harness fingerprints');
             output.writeln('  drift-from-history  iter 53 — diff current state against most recent audit (1-command drift)');
             output.writeln('  mint          scaffold a custom harness (dry-run by default)');
+            output.writeln('  redblue       adversarial red/blue LLM testing (init|run|patch|attack|report)');
             output.writeln('');
             output.writeln('Each subcommand accepts --format json|table and --help.');
             output.writeln('');
@@ -180,7 +195,7 @@ export const metaharnessCommand = {
             output.writeln(`Valid: ${Object.keys(SUBCOMMANDS).join(', ')}`);
             return { success: false, exitCode: 2, data: { subcommand } };
         }
-        const scriptDir = locatePluginScripts();
+        const scriptDir = locatePluginScripts(SUBCOMMANDS[subcommand]);
         if (!scriptDir) {
             output.writeln(output.warning('metaharness: plugins/ruflo-metaharness/scripts/ not found. Install ruflo with `npm i ruflo` or run from the ruflo repo.'));
             output.writeln(output.dim('(ADR-150 graceful degradation: this command is a thin delegator over the plugin; the plugin must be present.)'));

package/v3/@claude-flow/cli/dist/src/mcp-client.js

@@ -47,6 +47,9 @@ import { guidanceTools } from './mcp-tools/guidance-tools.js';
 import { autopilotTools } from './mcp-tools/autopilot-tools.js';
 // ADR-150 — MetaHarness MCP tools (score / genome / mcp-scan / threat-model / oia-audit)
 import { metaharnessTools } from './mcp-tools/metaharness-tools.js';
+// agenticow@~0.2.3 — Copy-On-Write memory branching tools (162-byte branches);
+// optional runtime dep, every handler returns `{degraded: true}` when missing.
+import { agenticowTools } from './mcp-tools/agenticow-tools.js';
 // #1916: coverage-aware routing tools — defined in ruvector/coverage-tools.ts
 // but were never registered, so the `ruflo hooks coverage-*` CLI subcommands
 // failed with `Tool not found: hooks_coverage-route`.
@@ -127,6 +130,8 @@ registerTools([
     ...coverageRouterTools,
     // ADR-150 — MetaHarness static-analysis tools (5)
     ...metaharnessTools,
+    // agenticow@~0.2.3 — COW memory branching (4 tools, graceful-degraded when missing)
+    ...agenticowTools,
 ]);
 /**
  * MCP Client Error

package/v3/@claude-flow/cli/dist/src/mcp-tools/agenticow-tools.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Agenticow MCP Tools — Copy-On-Write memory branching surface.
+ *
+ * Exposes `agenticow@~0.2.3` (a sibling RVF-based COW vector store by the same
+ * author as ruflo) as MCP tools so agents can branch, checkpoint, rollback,
+ * and promote memory state without copying GB-scale `.rvf` files.
+ *
+ * Motivation:
+ *   The v3.14.4 release uncovered a tarball-bloat regression where Darwin
+ *   loops' git-worktree-per-agent pattern accumulated 3.3 GB of disk. The
+ *   structural cause was full-copy snapshot semantics. Measured agenticow
+ *   branches are exactly 162 bytes regardless of base size (see
+ *   `docs/agenticow/findings.md` for the bench data).
+ *
+ * Architectural constraint (mirrors metaharness-tools.ts / testgen-tools.ts):
+ *   - `agenticow` lives in `optionalDependencies` — must NOT be a hard runtime dep
+ *   - When the package is missing, every tool returns
+ *     `{success: true, degraded: true, reason: 'agenticow-not-found'}`
+ *     so callers see one contract regardless of install state
+ *
+ * Measured performance vs published claims (agenticow@0.2.3):
+ *   ✅ 162-byte branches — confirmed exact
+ *   ✅ 3,000×–180,000× smaller than full-copy at N=1k–50k
+ *   ❌ 0.5 ms branch — measured ~10ms (fixed cost, not size-proportional)
+ *   ❌ 83× faster — only beats full-copy past N ≈ 30k crossover
+ *
+ * Use cases (per ADR / findings doc):
+ *   - Per-Darwin-iteration memory branching (eliminates worktree bloat)
+ *   - Per-user / per-session personalization (cheap fork, no full copy)
+ *   - Federation: branch → promote back as merge semantics
+ *
+ * @module @claude-flow/cli/mcp-tools/agenticow
+ */
+import type { MCPTool } from './types.js';
+export declare const agenticowTools: MCPTool[];
+//# sourceMappingURL=agenticow-tools.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/agenticow-tools.js

@@ -0,0 +1,253 @@
+/**
+ * Agenticow MCP Tools — Copy-On-Write memory branching surface.
+ *
+ * Exposes `agenticow@~0.2.3` (a sibling RVF-based COW vector store by the same
+ * author as ruflo) as MCP tools so agents can branch, checkpoint, rollback,
+ * and promote memory state without copying GB-scale `.rvf` files.
+ *
+ * Motivation:
+ *   The v3.14.4 release uncovered a tarball-bloat regression where Darwin
+ *   loops' git-worktree-per-agent pattern accumulated 3.3 GB of disk. The
+ *   structural cause was full-copy snapshot semantics. Measured agenticow
+ *   branches are exactly 162 bytes regardless of base size (see
+ *   `docs/agenticow/findings.md` for the bench data).
+ *
+ * Architectural constraint (mirrors metaharness-tools.ts / testgen-tools.ts):
+ *   - `agenticow` lives in `optionalDependencies` — must NOT be a hard runtime dep
+ *   - When the package is missing, every tool returns
+ *     `{success: true, degraded: true, reason: 'agenticow-not-found'}`
+ *     so callers see one contract regardless of install state
+ *
+ * Measured performance vs published claims (agenticow@0.2.3):
+ *   ✅ 162-byte branches — confirmed exact
+ *   ✅ 3,000×–180,000× smaller than full-copy at N=1k–50k
+ *   ❌ 0.5 ms branch — measured ~10ms (fixed cost, not size-proportional)
+ *   ❌ 83× faster — only beats full-copy past N ≈ 30k crossover
+ *
+ * Use cases (per ADR / findings doc):
+ *   - Per-Darwin-iteration memory branching (eliminates worktree bloat)
+ *   - Per-user / per-session personalization (cheap fork, no full copy)
+ *   - Federation: branch → promote back as merge semantics
+ *
+ * @module @claude-flow/cli/mcp-tools/agenticow
+ */
+import { existsSync } from 'node:fs';
+import { getProjectCwd } from './types.js';
+import { resolve, isAbsolute } from 'node:path';
+const PACKAGE_NAME = 'agenticow';
+// Cache: module load is expensive enough to amortize across handler calls.
+// null = not yet attempted; false = attempted and unavailable; module = loaded.
+let _agenticowMod = null;
+let _loadAttempted = false;
+async function loadAgenticow() {
+    if (_loadAttempted)
+        return _agenticowMod;
+    _loadAttempted = true;
+    try {
+        _agenticowMod = await import(PACKAGE_NAME);
+        return _agenticowMod;
+    }
+    catch (err) {
+        if (err && (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND' ||
+            /Cannot find (module|package)/i.test(String(err.message)))) {
+            _agenticowMod = false;
+            return null;
+        }
+        throw err;
+    }
+}
+function degradedResult(reason) {
+    return { success: true, degraded: true, reason };
+}
+function resolveMemoryPath(path) {
+    if (!path || typeof path !== 'string')
+        throw new Error('memory path is required');
+    // D-2 style: reject path traversal in user-supplied paths
+    if (/\.\.[\\/]|\0/.test(path))
+        throw new Error('memory path contains disallowed characters');
+    return isAbsolute(path) ? path : resolve(getProjectCwd(), path);
+}
+/**
+ * Lineage manifest companion path. agenticow persists the COW chain
+ * (working → checkpoints → base) into `<file>.agenticow.json` next to the
+ * `.rvf` data file. Without this, checkpoints and forks are in-memory only
+ * and disappear when the AgenticMemory handle closes. Mirrors the bin
+ * CLI's `manifestFor(file)` helper.
+ */
+function manifestFor(file) {
+    return `${file}.agenticow.json`;
+}
+function validateLabel(label) {
+    if (!label || typeof label !== 'string')
+        throw new Error('label is required');
+    if (label.length > 256)
+        throw new Error('label exceeds 256 chars');
+    if (!/^[A-Za-z0-9_.\-:/@]+$/.test(label)) {
+        throw new Error('label may only contain [A-Za-z0-9_.\\-:/@]');
+    }
+    return label;
+}
+/**
+ * Open (or create) a base memory file. When a lineage manifest exists at
+ * `<file>.agenticow.json`, we load that to restore the COW chain (checkpoints,
+ * ancestors). When only the `.rvf` exists, fresh-open it. When neither exists,
+ * dimension is required to create. Mirrors the bin CLI's `loadMem()` helper.
+ */
+async function openWithLineage(api, file, dimension) {
+    const manifest = manifestFor(file);
+    if (existsSync(manifest)) {
+        // The class-level static method `load` reconstructs the full chain.
+        return api.AgenticMemory.load(manifest);
+    }
+    const opts = {};
+    if (typeof dimension === 'number' && Number.isInteger(dimension) && dimension > 0) {
+        opts.dimension = dimension;
+    }
+    else if (!existsSync(file)) {
+        throw new Error('dimension is required when creating a new memory file');
+    }
+    return api.open(file, opts);
+}
+export const agenticowTools = [
+    {
+        name: 'agenticow_branch',
+        description: 'agenticow@~0.2.3 — COW-fork a base .rvf memory file. Measured 162-byte branches regardless of base size (verified at N=1k/10k/50k). Use when you need per-Darwin-iteration / per-user / per-session memory personalization. Copying the parent .rvf file is wrong because full-copy snapshots grow linearly (the 3.3 GB Darwin-worktree bloat fixed in v3.14.4); agenticow gives read-through semantics (parent ∪ edits, child wins) at constant 162 B. Optional dep — degrades to {degraded:true} when missing.',
+        category: 'memory',
+        tags: ['agenticow', 'memory', 'cow', 'branch'],
+        inputSchema: {
+            type: 'object',
+            properties: {
+                basePath: { type: 'string', description: 'Path to base .rvf memory file (absolute or relative to cwd)' },
+                branchPath: { type: 'string', description: 'Path to write the branch file' },
+                label: { type: 'string', description: 'Human-readable label for the branch (alnum + _.-:/@ only)' },
+                dimension: { type: 'integer', description: 'Vector dimension (required only when basePath does not exist yet)' },
+            },
+            required: ['basePath', 'branchPath', 'label'],
+        },
+        handler: async (input) => {
+            const api = await loadAgenticow();
+            if (!api)
+                return degradedResult('agenticow-not-found');
+            const label = validateLabel(String(input.label));
+            const basePath = resolveMemoryPath(String(input.basePath));
+            const branchPath = resolveMemoryPath(String(input.branchPath));
+            const dim = input.dimension;
+            const base = await openWithLineage(api, basePath, dim);
+            try {
+                const branch = await base.fork(label, branchPath);
+                // Persist lineage manifests so the branch (and base) reopen with
+                // their COW chain intact. Without this, fork is in-memory only.
+                await branch.save?.(manifestFor(branchPath));
+                await base.save?.(manifestFor(basePath));
+                await branch.close?.();
+                return {
+                    success: true,
+                    basePath,
+                    branchPath,
+                    label,
+                };
+            }
+            finally {
+                await base.close?.();
+            }
+        },
+    },
+    {
+        name: 'agenticow_checkpoint',
+        description: 'agenticow — freeze a labelled restore point on an .rvf memory file. Subsequent edits stay in a fresh COW child; rollback returns here. Use when you are about to run an experimental Darwin tick or speculative agent edit that may need to be discarded. Relying on the working node alone is wrong because there is no "undo last N writes" semantics — without a checkpoint, a bad ingest contaminates the base. Persists via .agenticow.json lineage manifest so it survives close+reopen.',
+        category: 'memory',
+        tags: ['agenticow', 'memory', 'cow', 'checkpoint'],
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to .rvf memory file' },
+                label: { type: 'string', description: 'Checkpoint label (alnum + _.-:/@ only)' },
+            },
+            required: ['path', 'label'],
+        },
+        handler: async (input) => {
+            const api = await loadAgenticow();
+            if (!api)
+                return degradedResult('agenticow-not-found');
+            const label = validateLabel(String(input.label));
+            const path = resolveMemoryPath(String(input.path));
+            const mem = await openWithLineage(api, path);
+            try {
+                const cp = await mem.checkpoint(label);
+                await mem.save?.(manifestFor(path));
+                return { success: true, path, label, checkpoint: cp };
+            }
+            finally {
+                await mem.close?.();
+            }
+        },
+    },
+    {
+        name: 'agenticow_rollback',
+        description: 'agenticow — discard all edits since the most recent checkpoint on an .rvf memory file. Reuses a fresh COW child derived from the checkpoint. Use when a Darwin tick or agent experiment regressed and you want to revert memory state without re-running. Deleting+rebuilding the .rvf is wrong because rebuild cost is O(N) and the data after the bad point is lost; rollback is O(edits-since-checkpoint) and the earlier history stays intact via the lineage manifest.',
+        category: 'memory',
+        tags: ['agenticow', 'memory', 'cow', 'rollback'],
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to .rvf memory file' },
+            },
+            required: ['path'],
+        },
+        handler: async (input) => {
+            const api = await loadAgenticow();
+            if (!api)
+                return degradedResult('agenticow-not-found');
+            const path = resolveMemoryPath(String(input.path));
+            const mem = await openWithLineage(api, path);
+            try {
+                const r = await mem.rollback();
+                await mem.save?.(manifestFor(path));
+                return { success: true, path, rolledBack: true, result: r };
+            }
+            finally {
+                await mem.close?.();
+            }
+        },
+    },
+    {
+        name: 'agenticow_promote',
+        description: 'agenticow — merge a branch\'s edits back into its base (or an explicit target) memory file. After promote, branch edits become part of base lineage. Use when a per-user / per-Darwin-iteration branch has been validated and should graduate to shared memory (federation merge, A/B winner). Manually re-ingesting edits into the base is wrong because the edit set is opaque to the caller and tombstones (deletions) are easily missed; promote applies the full edit + tombstone set atomically.',
+        category: 'memory',
+        tags: ['agenticow', 'memory', 'cow', 'promote', 'merge'],
+        inputSchema: {
+            type: 'object',
+            properties: {
+                branchPath: { type: 'string', description: 'Path to branch .rvf file' },
+                basePath: {
+                    type: 'string',
+                    description: 'Path to base .rvf file. When omitted, promote merges into the ' +
+                        'recorded fork parent (most common case).',
+                },
+            },
+            required: ['branchPath'],
+        },
+        handler: async (input) => {
+            const api = await loadAgenticow();
+            if (!api)
+                return degradedResult('agenticow-not-found');
+            const branchPath = resolveMemoryPath(String(input.branchPath));
+            const basePath = input.basePath ? resolveMemoryPath(String(input.basePath)) : undefined;
+            const branch = await openWithLineage(api, branchPath);
+            const base = basePath ? await openWithLineage(api, basePath) : undefined;
+            try {
+                const result = base ? await branch.promote(base) : await branch.promote();
+                // Persist mutated lineage so promote survives close+reopen
+                await branch.save?.(manifestFor(branchPath));
+                if (base && basePath)
+                    await base.save?.(manifestFor(basePath));
+                return { success: true, branchPath, basePath: basePath ?? null, promoted: result ?? true };
+            }
+            finally {
+                await branch.close?.();
+                await base?.close?.();
+            }
+        },
+    },
+];
+//# sourceMappingURL=agenticow-tools.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/index.d.ts

@@ -26,4 +26,5 @@ export { guidanceTools } from './guidance-tools.js';
 export { autopilotTools } from './autopilot-tools.js';
 export { metaharnessTools } from './metaharness-tools.js';
 export { testgenTools } from './testgen-tools.js';
+export { agenticowTools } from './agenticow-tools.js';
 //# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/index.js

@@ -27,4 +27,6 @@ export { autopilotTools } from './autopilot-tools.js';
 export { metaharnessTools } from './metaharness-tools.js';
 // ADR-175-inspired — Test-Driven Repair via headless `claude -p`
 export { testgenTools } from './testgen-tools.js';
+// agenticow@~0.2.3 — Copy-On-Write memory branching (162-byte branches)
+export { agenticowTools } from './agenticow-tools.js';
 //# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/metaharness-tools.d.ts

@@ -18,6 +18,12 @@
  *   - metaharness_security_bench upstream's "Darwin Shield" (their own ADR-155)
  *   - metaharness_bench          create/verify bench suites used by evolve --bench
  *
+ * @metaharness/redblue integration adds one tool that targets the standalone
+ * `@metaharness/redblue` npm package — adversarial red/blue LLM testing
+ * for the agents and apps you own:
+ *
+ *   - metaharness_redblue        red-team → judge → blue-patch → retest → report
+ *
  * Every tool resolves the corresponding plugin script
  * (`plugins/ruflo-metaharness/scripts/<X>.mjs`) via the same locator
  * the commands/metaharness.ts dispatcher uses, then spawns it with

package/v3/@claude-flow/cli/dist/src/mcp-tools/metaharness-tools.js

@@ -18,6 +18,12 @@
  *   - metaharness_security_bench upstream's "Darwin Shield" (their own ADR-155)
  *   - metaharness_bench          create/verify bench suites used by evolve --bench
  *
+ * @metaharness/redblue integration adds one tool that targets the standalone
+ * `@metaharness/redblue` npm package — adversarial red/blue LLM testing
+ * for the agents and apps you own:
+ *
+ *   - metaharness_redblue        red-team → judge → blue-patch → retest → report
+ *
  * Every tool resolves the corresponding plugin script
  * (`plugins/ruflo-metaharness/scripts/<X>.mjs`) via the same locator
  * the commands/metaharness.ts dispatcher uses, then spawns it with
@@ -42,8 +48,14 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
  * Walk up from this module to find plugins/ruflo-metaharness/scripts/.
  * Handles three install layouts (mirrors commands/metaharness.ts).
+ *
+ * `requiredScript`, if provided, narrows the match the same way the
+ * commands dispatcher does — guards against the publish-artifact mirror
+ * (`v3/@claude-flow/cli/plugins/ruflo-metaharness/scripts/`, regenerated
+ * by `prepublishOnly`) shadowing the source when it's stale on a new
+ * script.
  */
-function locatePluginScripts() {
+function locatePluginScripts(requiredScript) {
     const candidates = [];
     let p = resolve(__dirname);
     for (let i = 0; i < 8; i++) {
@@ -55,8 +67,11 @@ function locatePluginScripts() {
     candidates.push(join(cwd, 'plugins', 'ruflo-metaharness', 'scripts'));
     candidates.push(join(cwd, 'node_modules', '@claude-flow', 'cli', 'plugins', 'ruflo-metaharness', 'scripts'));
     for (const c of candidates) {
-        if (existsSync(join(c, '_harness.mjs')))
-            return c;
+        if (!existsSync(join(c, '_harness.mjs')))
+            continue;
+        if (requiredScript && !existsSync(join(c, requiredScript)))
+            continue;
+        return c;
     }
     return null;
 }
@@ -90,7 +105,7 @@ function locatePluginScripts() {
  */
 function runScript(scriptName, args) {
     return new Promise((resolve) => {
-        const dir = locatePluginScripts();
+        const dir = locatePluginScripts(scriptName);
         if (!dir) {
             resolve({
                 exitCode: 0, stdout: '', json: { degraded: true, reason: 'plugin-not-found' },
@@ -512,5 +527,69 @@ export const metaharnessTools = [
             return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
         },
     },
+    // ───────────────────────────────────────────────────────────────────────
+    // @metaharness/redblue integration (1 tool).
+    // Backed by `@metaharness/redblue@~0.1.1`. Plugin script shells out via
+    // _redblue.mjs. Same {success, data, degraded, exitCode} contract.
+    //
+    // SAFETY: redblue itself enforces hard boundaries (no real creds, no live
+    // targets, no shell, no arbitrary network, no eval) in upstream's
+    // src/config/safety.ts at config-load time. The wrapper does NOT relax
+    // those — it only forwards argv with shell:false. `--mock-judge` is the
+    // $0 marker-fixture CI path; the real model judge requires
+    // $OPENROUTER_API_KEY which we never inject.
+    // ───────────────────────────────────────────────────────────────────────
+    {
+        name: 'metaharness_redblue',
+        description: 'Adversarial red/blue LLM testing via @metaharness/redblue — generates attacks across OWASP LLM Top-10 / NIST AI RMF families (prompt injection, tool misuse, data leakage, jailbreaks, denial-of-wallet), runs them against an LLM target YOU OWN, judges compromise, optionally applies declarative blue-team patches, retests, and emits a board-readable report with measured failure reduction. Use when shipping an LLM-powered product and you need a repeatable security gate before exposing it to users — eyeballing prompts is wrong because attack surface coverage requires the OWASP/NIST taxonomy and the judge has to be model-driven for jailbreak detection. SAFETY: upstream hard-enforces no-creds / no-live-targets / no-shell / no-network / no-eval at config-load time; cannot be relaxed via flags. For CI / offline use --mockJudge=true ($0 marker fixture). For real model judging set $OPENROUTER_API_KEY and accept the per-run cost capped by max_cost_usd (default $3). ' + MCP_SUCCESS_SEMANTIC,
+        category: 'metaharness',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                subcommand: {
+                    type: 'string',
+                    enum: ['init', 'run', 'patch', 'attack', 'report'],
+                    description: 'init = scaffold redblue.yaml; run = baseline (+ optional --patch); patch = baseline → patch → retest delta; attack = preview attacks; report = render existing report.json',
+                    default: 'run',
+                },
+                config: { type: 'string', description: 'Path to redblue.yaml (default: ./redblue.yaml)' },
+                out: { type: 'string', description: 'Output report path for run/patch (default: temp file we read back inline)' },
+                in: { type: 'string', description: 'Input report path for `report` subcommand' },
+                tests: { type: 'number', description: 'How many test cases (run/patch only)' },
+                patch: { type: 'boolean', description: '`run` only — after baseline, apply blue-team patches and retest', default: false },
+                mockJudge: { type: 'boolean', description: '$0 TEST-ONLY marker fixture (no model calls). Use for CI / offline. Real judging requires OPENROUTER_API_KEY.', default: false },
+                family: { type: 'string', enum: ['prompt', 'tools', 'data', 'all'], description: '`attack` subcommand only — which attack family to preview' },
+                count: { type: 'number', description: '`attack` only — how many cases to preview' },
+                alertOnFail: { type: 'boolean', description: 'Exit 1 when post-patch verdict is FAIL (gate-style)', default: false },
+                timeoutMs: { type: 'number', description: 'Subprocess hard timeout (default 120000; mock-judge runs complete in seconds)' },
+            },
+        },
+        handler: async (input) => {
+            const args = [String(input.subcommand ?? 'run')];
+            // attack family is positional
+            if (input.subcommand === 'attack' && input.family)
+                args.push(String(input.family));
+            if (input.config)
+                args.push('--config', String(input.config));
+            if (input.out)
+                args.push('--out', String(input.out));
+            if (input.in)
+                args.push('--in', String(input.in));
+            if (input.tests !== undefined)
+                args.push('--tests', String(input.tests));
+            if (input.patch === true)
+                args.push('--patch');
+            if (input.mockJudge === true)
+                args.push('--mock-judge');
+            if (input.count !== undefined)
+                args.push('--count', String(input.count));
+            if (input.alertOnFail === true)
+                args.push('--alert-on-fail');
+            if (input.timeoutMs !== undefined)
+                args.push('--timeout-ms', String(input.timeoutMs));
+            const r = await runScript('redblue.mjs', args);
+            return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
+        },
+    },
 ];
 //# sourceMappingURL=metaharness-tools.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.14.4",
+  "version": "3.15.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",
@@ -106,6 +106,7 @@
     "yaml": "^2.8.0"
   },
   "optionalDependencies": {
+    "agenticow": "~0.2.3",
     "@claude-flow/aidefence": "^3.0.2",
     "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.18",
@@ -115,6 +116,7 @@
     "@claude-flow/security": "^3.0.0-alpha.10",
     "@metaharness/darwin": "~0.3.1",
     "@metaharness/kernel": "~0.1.0",
+    "@metaharness/redblue": "~0.1.1",
     "@metaharness/router": "~0.3.2",
     "metaharness": "~0.2.6",
     "@ruvector/attention": "^0.1.32",