@claude-flow/cli 3.45.0 → 3.46.0

package/plugins/ruflo-metaharness/scripts/_darwin.mjs

@@ -2,16 +2,17 @@
 //
 // Mirrors `_harness.mjs` for the umbrella `metaharness` / `harness` binaries,
 // but targets the separate darwin binary (`metaharness-darwin`) which is
-// published as its own npm package (`@metaharness/darwin@~0.8.0`).
+// published as its own npm package (`@metaharness/darwin@~0.10.2`).
 //
 // Shared plumbing (degraded classification, --json injection, trailing-JSON
 // parse, degraded emitter) lives in `_invoke.mjs`. What stays here is the
 // genuinely-darwin part: the ASYNC STREAMING variant (`runDarwinAsync`) that
 // long `evolve` runs need for per-generation progress visibility.
 //
-// Three subcommands surfaced (matches darwin 0.8.x — same verbs as 0.3.x,
-// with GEPA-engine evolve flags added upstream: --selection modes,
-// --crossover, --epistasis, --curriculum, --mutator ruvllm, --sandbox):
+// Three subcommands surfaced (matches darwin 0.8.x-0.10.x — same verbs as
+// 0.3.x, with GEPA-engine evolve flags added upstream: --selection modes,
+// --crossover, --epistasis, --curriculum, --mutator ruvllm, --sandbox;
+// 0.10.x only ADDS `evolve-numeric`, which this helper does not surface):
 //   - `metaharness-darwin evolve <repo> [...]`         — harness self-improvement
 //   - `metaharness-darwin bench <create|verify> ...`   — bench-suite lifecycle
 //   - `metaharness-darwin security bench [...]`        — Darwin Shield (upstream ADR-155)
@@ -31,23 +32,43 @@
 //   matched to their --generations × --children × sandbox cost; the 60s
 //   default is for `bench verify` and `security bench --population 2 --cycles 1`
 //   smoke shapes only.
+//
+// RESOLUTION (#3366 — was `npx -y -p @metaharness/darwin@<pin>` on every call)
+//   Same order as _harness.mjs: (a) an installed @metaharness/darwin that
+//   satisfies the pin (the @claude-flow/cli optionalDependency — free), then
+//   (b) the one-time versioned `~/.ruflo/darwin-cache-<pin>` install that gepa
+//   already shares, then `process.execPath <abs bin>` with shell:false. The
+//   npx path had npm resolve the range on every evolve / bench /
+//   security-bench call (registry or npx cache state), ignored the copy ruflo
+//   ships, and could run a different darwin than the gepa import in the same
+//   plugin. (a) searches ruflo's own tree only — see findLocalPackageDir's
+//   `fromCwd` in _invoke.mjs.
 
 import { spawnSync, spawn } from 'node:child_process';
 import {
   classifyDegraded,
+  ensureCachedInstall,
+  findLocalPackageDir,
   importOptionalLibrary,
   injectJson,
   makeDegradedEmitter,
+  packageBinRelPath,
   parseTrailingJson,
+  resolvePackageBin,
 } from './_invoke.mjs';
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
-// Pinned semver range. Bump in lock-step with optionalDependencies in
-// @claude-flow/cli/package.json + ruflo/package.json. The `~` allows
-// patch upgrades without re-pinning.
+// Pinned semver range. The `~` allows patch upgrades without re-pinning.
+// Must cover the `@metaharness/darwin` optionalDependency range in
+// v3/@claude-flow/cli/package.json (`~0.10.2`). It sat at ~0.8.0 while that
+// range moved to ~0.9.0 (#2958) and ~0.10.2 (#3262), because the pin-drift
+// guard only compared MH_DARWIN_PIN (distill-oracle.ts). This range picks
+// the darwin version the evolve / bench / security-bench tools run and the
+// gepa cache fallback installs; scripts/check-metaharness-pins.mjs now fails
+// when it no longer covers the declared range.
 const DARWIN_PKG = '@metaharness/darwin';
-const DARWIN_PIN_VERSION = '~0.8.0';
+const DARWIN_PIN_VERSION = '~0.10.2';
 const DARWIN_PIN = `${DARWIN_PKG}@${DARWIN_PIN_VERSION}`;
 
 const REASON_PREFIX = 'metaharness-darwin';
@@ -68,22 +89,71 @@ function buildArgv(args, wantJson) {
 // (This last-block parse is now the family-wide shared implementation.)
 const maybeParseJson = parseTrailingJson;
 
+const DARWIN_BIN = 'metaharness-darwin';
+
+/**
+ * Absolute path of the `metaharness-darwin` bin (see RESOLUTION above).
+ * Memoized per process, like _harness.mjs resolveMetaharnessBins().
+ */
+let RESOLVED = null;
+function resolveDarwinBin() {
+  if (RESOLVED) return RESOLVED;
+  // fromCwd:false — this lookup ends in a spawn of the bin with argv that
+  // comes from MCP input, so it only searches the ruflo install that owns
+  // this plugin, never the tool's cwd or its ancestors (see _invoke.mjs).
+  const localDir = findLocalPackageDir(DARWIN_PKG, DARWIN_PIN_VERSION, { fromCwd: false });
+  const localBin = localDir ? resolvePackageBin(localDir, DARWIN_BIN) : null;
+  if (localBin) return (RESOLVED = { ok: true, bin: localBin, source: 'local' });
+  let cached = ensureCachedInstall({ pkg: DARWIN_PKG, pinVersion: DARWIN_PIN_VERSION });
+  let cachedBin = cached.ok ? resolvePackageBin(cached.pkgDir, DARWIN_BIN) : null;
+  // The default cache probe is `<pkgDir>/package.json`, so a half-written
+  // cache — npm killed by the 180s install timeout, or two first calls
+  // installing into the same prefix — would count as installed forever and
+  // degrade every later call. npx repaired that by re-resolving; re-run the
+  // install once, probing the bin file itself, then give up (#3366).
+  if (cached.ok && !cachedBin) {
+    cached = ensureCachedInstall({
+      pkg: DARWIN_PKG,
+      pinVersion: DARWIN_PIN_VERSION,
+      cliRelPath: packageBinRelPath(cached.pkgDir, DARWIN_BIN) ?? 'dist/cli.js',
+    });
+    cachedBin = cached.ok ? resolvePackageBin(cached.pkgDir, DARWIN_BIN) : null;
+  }
+  if (cachedBin) return (RESOLVED = { ok: true, bin: cachedBin, source: 'cache' });
+  return (RESOLVED = {
+    ok: false,
+    stdout: cached.stdout ?? '',
+    stderr: cached.stderr ?? cached.error ?? `${DARWIN_PIN} has no ${DARWIN_BIN} bin`,
+  });
+}
+
+/** Same degraded shape the npx path produced when the package was unreachable. */
+function unavailable(resolved, start) {
+  return {
+    stdout: resolved.stdout, stderr: resolved.stderr,
+    exitCode: 127, json: null, durationMs: Date.now() - start,
+    degraded: true, reason: `${REASON_PREFIX}-not-available`,
+  };
+}
+
 /**
  * Sync invocation. Use for short subcommands (`bench verify`, smoke shapes).
  * Async variant below for long-running `evolve` calls.
  */
 export function runDarwin(args, opts = {}) {
   const start = Date.now();
+  const resolved = resolveDarwinBin();
+  if (!resolved.ok) return unavailable(resolved, start);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const wantJson = opts.json !== false;
   const argv = buildArgv(args, wantJson);
-  const r = spawnSync('npx', ['-y', '-p', DARWIN_PIN, 'metaharness-darwin', ...argv], {
+  const r = spawnSync(process.execPath, [resolved.bin, ...argv], {
     stdio: ['ignore', 'pipe', 'pipe'],
     encoding: 'utf-8',
     timeout: timeoutMs,
     cwd: opts.cwd,
     env: { ...process.env, ...(opts.env || {}) },
-    shell: process.platform === 'win32',
+    shell: false,
   });
   const durationMs = Date.now() - start;
   const stdout = r.stdout || '';
@@ -119,14 +189,16 @@ export function runDarwin(args, opts = {}) {
 export function runDarwinAsync(args, opts = {}) {
   return new Promise((resolve) => {
     const start = Date.now();
+    const resolved = resolveDarwinBin();
+    if (!resolved.ok) { resolve(unavailable(resolved, start)); return; }
     const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const wantJson = opts.json !== false;
     const argv = buildArgv(args, wantJson);
-    const p = spawn('npx', ['-y', '-p', DARWIN_PIN, 'metaharness-darwin', ...argv], {
+    const p = spawn(process.execPath, [resolved.bin, ...argv], {
       stdio: ['ignore', 'pipe', 'pipe'],
       cwd: opts.cwd,
       env: { ...process.env, ...(opts.env || {}) },
-      shell: process.platform === 'win32',
+      shell: false,
     });
     let stdout = '', stderr = '', stderrBuf = '';
     p.stdout?.on('data', (d) => { stdout += d.toString(); });

package/plugins/ruflo-metaharness/scripts/_harness.mjs

@@ -26,7 +26,8 @@
 //      arbitrary code on user machines on the very next skill invocation.
 //      The version is now PINNED to METAHARNESS_PIN_VERSION (tilde range —
 //      patch updates only) and only bumped deliberately, in lock-step with
-//      optionalDependencies in @claude-flow/cli + ruflo package.json.
+//      the range declared in @claude-flow/cli/package.json (enforced by
+//      scripts/check-metaharness-pins.mjs).
 //   2. PERF: @latest forced an npm-registry metadata check on EVERY call.
 //      Resolution is now (a) an already-installed local metaharness
 //      satisfying the pin (walk-up node_modules — free), then (b) a ONE-TIME
@@ -53,10 +54,15 @@ import {
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
-// Pinned semver range. Bump in lock-step with optionalDependencies in
-// @claude-flow/cli/package.json + ruflo/package.json. NEVER @latest.
+// Pinned semver range. NEVER @latest. Must cover the `metaharness` range
+// declared in v3/@claude-flow/cli/package.json (optional peer `^0.4.1`):
+// this constant decides which INSTALLED copy findLocalPackageDir() accepts,
+// so a range that misses the declared one rejects the copy ruflo ships and
+// npm-installs another at tool-call time. It sat at ~0.3.0 after the CLI
+// moved to ^0.4.1 (b8ec03f34) because nothing compared the two;
+// scripts/check-metaharness-pins.mjs now fails when they diverge.
 const METAHARNESS_PKG = 'metaharness';
-const METAHARNESS_PIN_VERSION = '~0.3.0';
+const METAHARNESS_PIN_VERSION = '~0.4.1';
 
 const REASON_NOT_AVAILABLE = 'metaharness-not-available';
 

package/plugins/ruflo-metaharness/scripts/_invoke.mjs

@@ -21,9 +21,15 @@
 //                             invalidate stale caches automatically
 //   - findLocalPackageDir()   walk-up node_modules resolution so an already
 //                             installed optionalDependency is used for free
+//   - resolvePackageBin()     realpath'd bin-map entry of a resolved package
+//                             (#3366 — lets _darwin/_redblue run the installed
+//                             copy instead of npx / a cache install)
 //   - importOptionalLibrary() bare-import → cached-install fallback for
 //                             library entries (gepa) — never throws on absence
 //   - makeDegradedEmitter()   the ADR-150 rule-#3 exit-0 degraded payload
+//   - runRufloCli()           `memory store|list|retrieve` through the ruflo CLI
+//                             that ships this plugin (#3366) — replaces
+//                             `npx @claude-flow/cli@latest` in 4 scripts
 //
 // WHAT DOES NOT LIVE HERE (the per-consumer parts):
 //   - _redblue's node-direct isMain workaround rationale
@@ -36,7 +42,7 @@
 //   - RUFLO_METAHARNESS_SKIP_LOCAL=1 disables local node_modules resolution
 
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -102,11 +108,22 @@ export function satisfiesTildeRange(version, pinVersion) {
  * user's ruflo install shipped with). Returns the package dir or null.
  * When `pinVersion` is given, only a copy satisfying the pin is accepted —
  * a stale major/minor in an ancestor node_modules is skipped, not used.
+ *
+ * `{ fromCwd: false }` (#3366) searches ONLY the ruflo install that owns this
+ * plugin. The $CWD walk reaches every ancestor of the tool's working
+ * directory, i.e. directories the user's project — or anything above it —
+ * controls. That is tolerable for the pre-existing `metaharness` lookup,
+ * which this PR does not change, but the two lookups added here (_darwin,
+ * _redblue) END IN A SPAWN of the package's bin with MCP-supplied argv, so
+ * they stay inside ruflo's own tree and fall back to the pinned cache
+ * install instead.
  */
-export function findLocalPackageDir(pkg, pinVersion) {
+export function findLocalPackageDir(pkg, pinVersion, { fromCwd = true } = {}) {
   if (process.env.RUFLO_METAHARNESS_SKIP_LOCAL === '1') return null;
   const segments = pkg.split('/');
-  const starts = [dirname(fileURLToPath(import.meta.url)), process.cwd()];
+  const starts = fromCwd
+    ? [dirname(fileURLToPath(import.meta.url)), process.cwd()]
+    : [dirname(fileURLToPath(import.meta.url))];
   const seen = new Set();
   for (const start of starts) {
     let dir = start;
@@ -131,17 +148,51 @@ export function findLocalPackageDir(pkg, pinVersion) {
   return null;
 }
 
+/**
+ * Absolute path of `binName` from the package.json `bin` map of an already
+ * resolved package dir (findLocalPackageDir / ensureCachedInstall), or null.
+ * Read from the bin map rather than hardcoded, same as _harness.mjs.
+ *
+ * REALPATH'd on purpose (#3366): pnpm and other symlinked layouts hand us a
+ * symlinked package dir, and @metaharness/redblue's CLI only dispatches when
+ * `import.meta.url === file://${process.argv[1]}` (see _redblue.mjs) — Node
+ * reports import.meta.url as the REAL path, so argv[1] has to be one too or
+ * the CLI exits 0 having done nothing.
+ */
+export function resolvePackageBin(pkgDir, binName) {
+  const rel = packageBinRelPath(pkgDir, binName);
+  if (!rel) return null;
+  try {
+    const abs = join(pkgDir, rel);
+    return existsSync(abs) ? realpathSync(abs) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The package.json `bin` entry for `binName`, as declared (relative), or null. */
+export function packageBinRelPath(pkgDir, binName) {
+  try {
+    const pj = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf-8'));
+    const rel = typeof pj.bin === 'string' ? pj.bin : pj.bin?.[binName];
+    return rel || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * One-time versioned cache install of a PINNED range. Generalizes
  * gepa.mjs:98-121 / _redblue.mjs:72-102. The cache dir is
  * `<base>/<shortname>-cache-<pin-digits>` (e.g. redblue-cache-0.1.4,
- * darwin-cache-0.8.0, metaharness-cache-0.3.0) so existing caches created
+ * darwin-cache-0.10.2, metaharness-cache-0.4.1) so existing caches created
  * by the pre-consolidation helpers remain valid, and bumping the pin
- * invalidates stale installs automatically.
+ * invalidates stale installs automatically (the pre-bump darwin-cache-0.8.0
+ * and metaharness-cache-0.3.0 dirs are simply no longer selected).
  *
  * @param {object} spec
  * @param {string} spec.pkg          npm package name (may be scoped)
- * @param {string} spec.pinVersion   tilde range, e.g. '~0.3.0'
+ * @param {string} spec.pinVersion   tilde range, e.g. '~0.4.1'
  * @param {string} [spec.cliRelPath] path inside the package that must exist
  *                                   post-install (also returned as cliPath)
  * @param {number} [spec.timeoutMs]  install timeout (default 180s)
@@ -228,3 +279,66 @@ export function makeDegradedEmitter(pkg, pinVersion) {
     process.exit(0);
   };
 }
+
+// ---------------------------------------------------------------------------
+// The ruflo CLI that ships this plugin (#3366)
+// ---------------------------------------------------------------------------
+// audit-list / audit-trend / oia-audit / similarity read and write the
+// `metaharness-audit` memory namespace through the ruflo CLI. They used to
+// spawn `npx @claude-flow/cli@latest memory …`, which on every call:
+//   - resolved `latest` through the npm registry (the "metadata check on
+//     EVERY call" _harness.mjs removed for its own npx path); without registry
+//     access it fails, so oia_audit reports `persisted: false` and audit_list
+//     silently reports 0 records;
+//   - could run a DIFFERENT @claude-flow/cli than the one that spawned the
+//     tool (npx cache vs registry skew — #3306), i.e. another memory backend /
+//     schema than the MCP server's own memory_* tools see;
+//   - cold-fetched the whole CLI when the npx cache was empty (#3145, #3154).
+// The plugin is published INSIDE @claude-flow/cli
+// (<cli>/plugins/ruflo-metaharness/scripts — see prepare-publish.mjs), and the
+// MCP server / `ruflo metaharness` dispatcher locate it by walking up from
+// their own dist/, so the owning CLI is two directories above this plugin.
+// It is run with process.execPath + bin/cli.js (the mcp-launch.cjs /
+// daemon-autostart.ts pattern). A candidate only counts when dist/src/index.js
+// exists next to bin/cli.js — mcp-launch.cjs resolveLocalCliBin()'s guard
+// against an unbuilt checkout — AND its package.json is named
+// @claude-flow/cli, a check added here so an unrelated directory two levels up
+// can never qualify. Unchanged:
+//   - CLI_CORE=1 still opts into `npx @claude-flow/cli-core@alpha` (ADR-100);
+//   - no usable local CLI (e.g. a marketplace clone with no build) still falls
+//     back to `npx @claude-flow/cli@latest`.
+const PLUGIN_SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));
+
+let RUFLO_CLI = null;
+/** `{ command, args, shell, source }` for invoking the ruflo CLI. Memoized. */
+export function resolveRufloCli() {
+  if (RUFLO_CLI) return RUFLO_CLI;
+  if (process.env.CLI_CORE === '1') {
+    return (RUFLO_CLI = { command: 'npx', args: ['@claude-flow/cli-core@alpha'], shell: process.platform === 'win32', source: 'npx-cli-core' });
+  }
+  const candidates = [
+    join(PLUGIN_SCRIPTS_DIR, '..', '..', '..'),                              // published: <cli>/plugins/ruflo-metaharness/scripts
+    join(PLUGIN_SCRIPTS_DIR, '..', '..', '..', 'v3', '@claude-flow', 'cli'), // repo checkout / marketplace clone
+  ];
+  for (const dir of candidates) {
+    try {
+      const bin = join(dir, 'bin', 'cli.js');
+      const pj = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+      if (pj.name === '@claude-flow/cli' && existsSync(bin) && existsSync(join(dir, 'dist', 'src', 'index.js'))) {
+        return (RUFLO_CLI = { command: process.execPath, args: [bin], shell: false, source: 'local' });
+      }
+    } catch { /* not this layout — try the next */ }
+  }
+  return (RUFLO_CLI = { command: 'npx', args: ['@claude-flow/cli@latest'], shell: process.platform === 'win32', source: 'npx' });
+}
+
+/** spawnSync the ruflo CLI with `args` (e.g. ['memory', 'list', …]); same result shape as before. */
+export function runRufloCli(args, opts = {}) {
+  const cli = resolveRufloCli();
+  return spawnSync(cli.command, [...cli.args, ...args], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf-8',
+    shell: cli.shell,
+    ...opts,
+  });
+}

package/plugins/ruflo-metaharness/scripts/_redblue.mjs

@@ -32,6 +32,16 @@
 // (file separately — when fixed, we could go back to a bin-shim pattern,
 // though the node-direct cached path is now the family-wide standard anyway).
 //
+// INSTALLED COPY FIRST (#3366): an @metaharness/redblue already on disk that
+// satisfies the pin (a ruflo 3.42.4 install carries 0.1.4, via metaharness /
+// ruvector) is used before the cache install, same order as _harness.mjs /
+// _darwin.mjs. Previously the first call always ran `npm install` into the
+// cache even with that copy present.
+// Whichever copy is chosen, its CLI path is realpath'd
+// (_invoke.resolvePackageBin / realpathSync): a pnpm-symlinked package dir,
+// or a cache base under a symlink such as macOS /tmp -> /private/tmp, would
+// otherwise hit the same isMain mismatch described above.
+//
 // CONTRACT (matches runMetaharness/runDarwin):
 //   - returns `{ stdout, stderr, exitCode, durationMs, degraded, reason? }`
 //   - subprocess hard timeout (default 120s; --mock-judge runs are seconds)
@@ -47,12 +57,15 @@
 //   $OPENROUTER_API_KEY which we never inject.
 
 import { spawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import {
   classifyDegraded,
   ensureCachedInstall,
+  findLocalPackageDir,
   makeDegradedEmitter,
+  resolvePackageBin,
 } from './_invoke.mjs';
 
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -80,8 +93,15 @@ export function runRedblue(args, opts = {}) {
   const start = Date.now();
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
-  // 1. Ensure redblue is installed in our cache dir (one-time install).
-  const install = ensureCachedInstall({
+  // 0. An installed copy satisfying the pin — free, no npm (#3366).
+  //    fromCwd:false: the resolved bin is SPAWNED with argv that comes from
+  //    MCP input, so only ruflo's own tree is searched, never the tool's cwd
+  //    or its ancestors (see findLocalPackageDir in _invoke.mjs).
+  const localDir = findLocalPackageDir(REDBLUE_PKG, REDBLUE_PIN_VERSION, { fromCwd: false });
+  const localCli = localDir ? resolvePackageBin(localDir, 'redblue') : null;
+
+  // 1. Otherwise ensure redblue is installed in our cache dir (one-time install).
+  const install = localCli ? { ok: true, cliPath: localCli } : ensureCachedInstall({
     pkg: REDBLUE_PKG,
     pinVersion: REDBLUE_PIN_VERSION,
     cliRelPath: CLI_REL_PATH,
@@ -99,15 +119,22 @@ export function runRedblue(args, opts = {}) {
     };
   }
 
-  // 2. Invoke `node <real-path-to-cli> <args>` so upstream's isMain check
-  //    succeeds (argv[1] matches import.meta.url).
-  const r = spawnSync('node', [install.cliPath, ...args], {
+  // 2. Invoke `<this node> <real-path-to-cli> <args>` so upstream's isMain
+  //    check succeeds (argv[1] matches import.meta.url) — realpath'd, see
+  //    header. process.execPath + shell:false, like _darwin/_harness: the
+  //    argv carries MCP-supplied values (--config / --out / --in), and with
+  //    shell:true on win32 Node hands cmd.exe one unquoted string, so a value
+  //    such as `x.yaml & whoami` would run as a command (and a path with a
+  //    space — `C:\Program Files\…` — would break). node needs no shell.
+  let cliPath = install.cliPath;
+  try { cliPath = realpathSync(cliPath); } catch { /* missing — node's MODULE_NOT_FOUND → degraded below */ }
+  const r = spawnSync(process.execPath, [cliPath, ...args], {
     stdio: ['ignore', 'pipe', 'pipe'],
     encoding: 'utf-8',
     timeout: timeoutMs,
     cwd: opts.cwd,
     env: { ...process.env, ...(opts.env || {}) },
-    shell: process.platform === 'win32',
+    shell: false,
   });
   const durationMs = Date.now() - start;
   const stdout = r.stdout || '';

package/plugins/ruflo-metaharness/scripts/audit-list.mjs

@@ -16,12 +16,13 @@
 //   0  ok
 //   2  config error
 
-import { spawnSync } from 'node:child_process';
+import { runRufloCli } from './_invoke.mjs';
 
 const NS = process.env.AUDIT_LIST_NAMESPACE || 'metaharness-audit';
-const CLI_PKG = process.env.CLI_CORE === '1'
-  ? '@claude-flow/cli-core@alpha'
-  : '@claude-flow/cli@latest';
+// #3366 — memory calls go through runRufloCli() (_invoke.mjs): the ruflo CLI
+// that ships this plugin, not `npx @claude-flow/cli@latest` (npm-registry
+// resolution per call, possible version skew, fails without registry access).
+// CLI_CORE=1 still opts into `npx @claude-flow/cli-core@alpha`.
 
 const ARGS = (() => {
   const a = { limit: 20, since: null, format: 'table' };
@@ -43,10 +44,10 @@ function parseDurationMs(spec) {
 }
 
 function memList() {
-  const r = spawnSync('npx', [
-    CLI_PKG, 'memory', 'list',
+  const r = runRufloCli([
+    'memory', 'list',
     '--namespace', NS, '--format', 'json',
-  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  ]);
   if (r.status !== 0) return [];
   const m = /\[[\s\S]*\]/.exec(r.stdout || '');
   if (!m) return [];
@@ -54,10 +55,10 @@ function memList() {
 }
 
 function memRetrieve(key) {
-  const r = spawnSync('npx', [
-    CLI_PKG, 'memory', 'retrieve',
+  const r = runRufloCli([
+    'memory', 'retrieve',
     '--namespace', NS, '--key', key,
-  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  ]);
   if (r.status !== 0) return null;
   const m = /\{[\s\S]*\}/.exec(r.stdout || '');
   if (!m) return null;

package/plugins/ruflo-metaharness/scripts/audit-trend.mjs

@@ -25,7 +25,7 @@
 //   2  config error or input not found
 
 import { readFileSync, existsSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import { runRufloCli } from './_invoke.mjs';
 // iter 38 — structural-distance drift via ADR-152 §3.1 production module.
 // Falls back to null if either record predates iter-38 oia-audit (no
 // fingerprint field) — graceful degradation, never throws.
@@ -36,9 +36,10 @@ import { SEVERITY_RANK, rankSeverity } from './_harness.mjs';
 
 // iter 63 — SEVERITY_RANK moved to _harness.mjs (imported above)
 const NS = process.env.AUDIT_TREND_NAMESPACE || 'metaharness-audit';
-const CLI_PKG = process.env.CLI_CORE === '1'
-  ? '@claude-flow/cli-core@alpha'
-  : '@claude-flow/cli@latest';
+// #3366 — memory calls go through runRufloCli() (_invoke.mjs): the ruflo CLI
+// that ships this plugin, not `npx @claude-flow/cli@latest` (npm-registry
+// resolution per call, possible version skew, fails without registry access).
+// CLI_CORE=1 still opts into `npx @claude-flow/cli-core@alpha`.
 
 const ARGS = (() => {
   const a = {
@@ -62,10 +63,10 @@ const ARGS = (() => {
 })();
 
 function memRetrieve(key) {
-  const r = spawnSync('npx', [
-    CLI_PKG, 'memory', 'retrieve',
+  const r = runRufloCli([
+    'memory', 'retrieve',
     '--namespace', NS, '--key', key,
-  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  ]);
   if (r.status !== 0) return null;
   const m = /\{[\s\S]*\}/.exec(r.stdout || '');
   if (!m) return null;

package/plugins/ruflo-metaharness/scripts/drift-from-history.mjs

@@ -42,9 +42,8 @@ import { fileURLToPath } from 'node:url';
 
 const SCRIPTS_DIR = dirname(fileURLToPath(import.meta.url));
 const NS = process.env.METAHARNESS_AUDIT_NAMESPACE || 'metaharness-audit';
-const CLI_PKG = process.env.CLI_CORE === '1'
-  ? '@claude-flow/cli-core@alpha'
-  : '@claude-flow/cli@latest';
+// Memory access is delegated to audit-list / oia-audit / audit-trend (they
+// call the shipping ruflo CLI through _invoke.runRufloCli — #3366).
 
 const ARGS = (() => {
   const a = {

package/plugins/ruflo-metaharness/scripts/oia-audit.mjs

@@ -24,7 +24,7 @@
 //   1  --alert-on-worst threshold exceeded
 //   2  config error or audit failure
 
-import { spawnSync } from 'node:child_process';
+import { runRufloCli } from './_invoke.mjs';
 // iter 63 — SEVERITY_RANK + rankSeverity consolidated to _harness.mjs
 // (was local in iter 62; now shared with audit-trend + mcp-scan).
 import { runHarness, runMetaharness, runHarnessAsync, runMetaharnessAsync, emitDegradedJsonAndExit, parseMcpScanText, SEVERITY_RANK, rankSeverity } from './_harness.mjs';
@@ -33,9 +33,10 @@ import { runHarness, runMetaharness, runHarnessAsync, runMetaharnessAsync, emitD
 // source of truth). The local copy from iter 62 is gone; the imports
 // at the top of this file provide the same names.
 const NS = process.env.OIA_AUDIT_NAMESPACE || 'metaharness-audit';
-const CLI_PKG = process.env.CLI_CORE === '1'
-  ? '@claude-flow/cli-core@alpha'
-  : '@claude-flow/cli@latest';
+// #3366 — memory calls go through runRufloCli() (_invoke.mjs): the ruflo CLI
+// that ships this plugin, not `npx @claude-flow/cli@latest` (npm-registry
+// resolution per call, possible version skew, fails without registry access).
+// CLI_CORE=1 still opts into `npx @claude-flow/cli-core@alpha`.
 
 const ARGS = (() => {
   const a = { path: '.', format: 'json', dryRun: false, alertWorst: null };
@@ -97,12 +98,12 @@ async function runAllParallel(path) {
 
 function persist(payload) {
   const key = `audit-${new Date().toISOString().replace(/[:.]/g, '-')}`;
-  const r = spawnSync('npx', [
-    CLI_PKG, 'memory', 'store',
+  const r = runRufloCli([
+    'memory', 'store',
     '--namespace', NS,
     '--key', key,
     '--value', JSON.stringify(payload),
-  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  ]);
   return {
     ok: r.status === 0,
     namespace: NS,

package/plugins/ruflo-metaharness/scripts/similarity.mjs

@@ -18,19 +18,20 @@
 //
 // ADR-150 ARCHITECTURAL CONSTRAINTS PRESERVED
 //   - Pure-TS function (`_similarity.mjs`), no `@metaharness/*` import
-//   - No new dep; uses node:fs + node:child_process only for memory lookup
+//   - No new dep; uses node:fs + _invoke.runRufloCli only for memory lookup
 //   - Graceful degradation: missing keys / malformed JSON → exit 2 with
 //     a structured `{ degraded: true, reason: ... }` payload on stdout
 //   - CI-gate ready: smoke step 17y locks this contract
 
 import { readFileSync, existsSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import { runRufloCli } from './_invoke.mjs';
 import { similarity } from './_similarity.mjs';
 
 const NS = process.env.HARNESS_SIMILARITY_NAMESPACE || 'metaharness-audit';
-const CLI_PKG = process.env.CLI_CORE === '1'
-  ? '@claude-flow/cli-core@alpha'
-  : '@claude-flow/cli@latest';
+// #3366 — memory calls go through runRufloCli() (_invoke.mjs): the ruflo CLI
+// that ships this plugin, not `npx @claude-flow/cli@latest` (npm-registry
+// resolution per call, possible version skew, fails without registry access).
+// CLI_CORE=1 still opts into `npx @claude-flow/cli-core@alpha`.
 
 const ARGS = (() => {
   const a = {
@@ -66,10 +67,10 @@ function emitDegradedAndExit(reason, code = 2) {
 }
 
 function memRetrieve(key) {
-  const r = spawnSync('npx', [
-    CLI_PKG, 'memory', 'retrieve',
+  const r = runRufloCli([
+    'memory', 'retrieve',
     '--namespace', NS, '--key', key,
-  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  ]);
   if (r.status !== 0) return null;
   const m = /\{[\s\S]*\}/.exec(r.stdout || '');
   if (!m) return null;